dsh-voice-mode 0.2.2 → 0.3.0

package/lib/index.js

@@ -4,25 +4,199 @@ import { join as join2 } from "node:path";
 import { homedir } from "node:os";
 
 // src/asr-host.ts
-import { createWriteStream } from "node:fs";
+import { createWriteStream, statSync } from "node:fs";
 import { mkdir, rename, stat, unlink } from "node:fs/promises";
 import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { Worker } from "node:worker_threads";
+
+// src/sense-worker.ts
+import { parentPort, workerData } from "node:worker_threads";
+function createSenseWorkerClient(worker) {
+  let counter = 0;
+  const pending = /* @__PURE__ */ new Map();
+  let dead = false;
+  const deathFns = /* @__PURE__ */ new Set();
+  const die = () => {
+    if (dead) return;
+    dead = true;
+    for (const fn of deathFns) {
+      try {
+        fn();
+      } catch {
+      }
+    }
+  };
+  worker.on?.("message", (msg) => {
+    const p = pending.get(msg?.id);
+    if (!p) return;
+    pending.delete(msg.id);
+    if (!msg.ok) {
+      p.resolve(null);
+      return;
+    }
+    p.resolve(p.op === "create" ? true : msg.text ?? "");
+  });
+  worker.on?.("error", (e) => {
+    die();
+    const err = new Error("sense worker error: " + String(e?.message ?? e));
+    for (const [, p] of pending) p.reject(err);
+    pending.clear();
+  });
+  worker.on?.("exit", () => {
+    die();
+    const err = new Error("sense worker exited");
+    for (const [, p] of pending) p.reject(err);
+    pending.clear();
+  });
+  const request = (op, samples) => {
+    if (dead) return Promise.reject(new Error("sense worker dead"));
+    const id = counter++;
+    return new Promise((resolve, reject) => {
+      pending.set(id, { op, resolve, reject });
+      const msg = { id, op };
+      if (samples) msg.samples = samples;
+      try {
+        worker.postMessage(msg);
+      } catch (e) {
+        pending.delete(id);
+        reject(e instanceof Error ? e : new Error(String(e)));
+      }
+    });
+  };
+  return {
+    request,
+    onDeath(fn) {
+      deathFns.add(fn);
+    },
+    terminate: async () => {
+      dead = true;
+      const err = new Error("sense worker terminated");
+      for (const [, p] of pending) p.reject(err);
+      pending.clear();
+      try {
+        await worker.terminate?.();
+      } catch {
+      }
+    }
+  };
+}
+function startSenseWorker(data) {
+  const port = parentPort;
+  if (!port) return;
+  let recognizer = null;
+  let sherpa = null;
+  port.on("message", async (msg) => {
+    try {
+      if (msg.op === "create" || msg.op === "decode") {
+        if (!sherpa) {
+          sherpa = await import(data.sherpaModule);
+        }
+        if (!recognizer) {
+          recognizer = sherpa.createOfflineRecognizer({
+            featConfig: { sampleRate: 16e3, featureDim: 80 },
+            modelConfig: {
+              senseVoice: {
+                model: data.modelDir + "/model.int8.onnx",
+                language: "auto",
+                useInverseTextNormalization: 1
+              },
+              tokens: data.modelDir + "/tokens.txt",
+              provider: "cpu",
+              debug: 0
+            }
+          });
+        }
+        if (msg.op === "decode" && msg.samples) {
+          const stream = recognizer.createStream();
+          try {
+            stream.acceptWaveform(16e3, msg.samples);
+            recognizer.decode(stream);
+            const text = recognizer.getResult(stream).text.trim();
+            port.postMessage({ id: msg.id, ok: true, text });
+          } finally {
+            try {
+              stream.free();
+            } catch {
+            }
+          }
+          return;
+        }
+        port.postMessage({ id: msg.id, ok: true, text: "" });
+        return;
+      }
+      port.postMessage({ id: msg.id, ok: false, error: "unknown op: " + msg.op });
+    } catch (e) {
+      port.postMessage({ id: msg.id, ok: false, error: String(e) });
+    }
+  });
+}
+if (parentPort) {
+  startSenseWorker(workerData);
+}
+
+// src/asr-host.ts
 import sherpa_onnx from "sherpa-onnx";
-var { createOnlineRecognizer } = sherpa_onnx;
+var { createOnlineRecognizer, createVad } = sherpa_onnx;
 var MODEL_REPO = "csukuangfj/sherpa-onnx-streaming-zipformer-zh-int8-2025-06-30";
 var MODEL_FILES = ["encoder.int8.onnx", "decoder.onnx", "joiner.int8.onnx", "tokens.txt"];
+var VAD_REPO = "csukuangfj/vad";
+var VAD_FILES = ["silero_vad.onnx"];
+var SENSE_REPO = "csukuangfj/sherpa-onnx-sense-voice-zh-en-ja-ko-yue-2024-07-17";
+var SENSE_FILES = ["model.int8.onnx", "tokens.txt"];
 function pcmToSamples(buf) {
-  if (buf.length % 4 !== 0 || buf.length === 0) return null;
+  if (buf.length % 4 !== 0) return null;
   return new Float32Array(buf.buffer, buf.byteOffset, buf.length / 4);
 }
 var MAX_ASR_BYTES = 4 * 1024 * 1024;
+var SEGMENT_IDLE_MS = 9e4;
+var VAD_CONTINUE_RMS = 0.02;
+var CONFIRM_CONJUNCTION_MS = 800;
+var CONFIRM_LONG_SENTENCE_MS = 350;
+var CONFIRM_LONG_SENTENCE_S = 8;
+var CONFIRM_MIN_MS = 400;
+var CONJUNCTION_TAIL = /(然后|还有|以及|并且|而且|此外|再说|接着|然后呢|比方说|比如说|比如|例如|等等|或者|或是|还有呢)$/;
+function endpointConfirmMs(text, spokenMs) {
+  const tail = text.trimEnd();
+  if (CONJUNCTION_TAIL.test(tail)) return CONFIRM_CONJUNCTION_MS;
+  if (spokenMs > CONFIRM_LONG_SENTENCE_S * 1e3) return CONFIRM_LONG_SENTENCE_MS;
+  return 0;
+}
+function rmsOf(samples) {
+  if (samples.length === 0) return 0;
+  let sum = 0;
+  for (let i = 0; i < samples.length; i++) sum += samples[i] * samples[i];
+  return Math.sqrt(sum / samples.length);
+}
 function createAsrRuntime(options) {
-  const { cacheDir, modelHost, broadcast } = options;
+  const { cacheDir, modelHost, broadcast, senseVoice } = options;
+  let lastProgress = null;
+  const localBroadcast = (event, payload) => {
+    if (event === "asr-progress") lastProgress = payload;
+    broadcast(event, payload);
+  };
   const repoDir = join(cacheDir, MODEL_REPO);
+  const vadDir = join(cacheDir, VAD_REPO);
+  const senseDir = join(cacheDir, SENSE_REPO);
+  const modelHosts = () => {
+    const seen = /* @__PURE__ */ new Set();
+    const out = [];
+    for (const h of [modelHost(), HOST_PRIMARY, HOST_FALLBACK]) {
+      const v = (h ?? "").trim().replace(/\/+$/, "");
+      if (!v || seen.has(v)) continue;
+      seen.add(v);
+      out.push(v);
+    }
+    return out;
+  };
   const segments = /* @__PURE__ */ new Map();
+  const finalized = /* @__PURE__ */ new Map();
+  const finalizing = /* @__PURE__ */ new Map();
+  const resetGen = /* @__PURE__ */ new Map();
   let recognizer = null;
   let modelsReady = false;
   let modelsLoading = null;
+  let asrFailAt = 0;
   const haveAllModels = async () => {
     for (const f of MODEL_FILES) {
       const st = await stat(join(repoDir, f)).catch(() => null);
@@ -32,11 +206,13 @@ function createAsrRuntime(options) {
   };
   const ensureModels = async () => {
     if (modelsReady) return true;
+    if (Date.now() < asrFailAt) return false;
     if (!modelsLoading) {
       modelsLoading = (async () => {
         if (!await haveAllModels()) {
           for (const f of MODEL_FILES) {
-            if (!await ensureFile(repoDir, f, modelHost(), broadcast)) {
+            if (!await ensureFile(repoDir, MODEL_REPO, f, modelHosts(), localBroadcast)) {
+              asrFailAt = Date.now() + 6e4;
               broadcast("asr-error", { file: f });
               return false;
             }
@@ -71,43 +247,452 @@ function createAsrRuntime(options) {
     });
     return recognizer;
   };
-  const feed = async (sessionId, samples, final) => {
+  let vadModelReady = false;
+  let vadLoading = null;
+  let vadFailAt = 0;
+  const ensureVadModel = async () => {
+    if (vadModelReady) return join(vadDir, VAD_FILES[0]);
+    if (Date.now() < vadFailAt) return null;
+    if (!vadLoading) {
+      vadLoading = (async () => {
+        for (const f of VAD_FILES) {
+          if (!await ensureFile(vadDir, VAD_REPO, f, modelHosts(), localBroadcast)) {
+            vadFailAt = Date.now() + 6e4;
+            return null;
+          }
+        }
+        vadModelReady = true;
+        return join(vadDir, VAD_FILES[0]);
+      })().finally(() => {
+        vadLoading = null;
+      });
+    }
+    return vadLoading;
+  };
+  const newVad = (vadPath, threshold = 0.5) => createVad({
+    sileroVad: {
+      model: vadPath,
+      threshold,
+      minSilenceDuration: 0.5,
+      minSpeechDuration: 0.25,
+      maxSpeechDuration: 20,
+      windowSize: 512
+    },
+    sampleRate: 16e3,
+    numThreads: 1,
+    provider: "cpu",
+    debug: 0,
+    bufferSizeInSeconds: 30
+  });
+  const ensureSessionVad = async (seg) => {
+    if (seg.vad) return seg.vad;
+    const vadPath = await ensureVadModel();
+    if (!vadPath) return null;
+    seg.vad = newVad(vadPath);
+    return seg.vad;
+  };
+  const detectVads = /* @__PURE__ */ new Map();
+  const detectVadLastUse = /* @__PURE__ */ new Map();
+  const ensureDetectVad = async (sessionId) => {
+    const existing = detectVads.get(sessionId);
+    if (existing) return existing;
+    const vadPath = await ensureVadModel();
+    if (!vadPath) return null;
+    const vad = newVad(vadPath, 0.35);
+    detectVads.set(sessionId, vad);
+    return vad;
+  };
+  let senseModelReady = false;
+  let senseLoading = null;
+  let senseFailAt = 0;
+  const ensureSenseModel = async () => {
+    if (senseModelReady) return join(senseDir, SENSE_FILES[0]);
+    if (Date.now() < senseFailAt) return null;
+    if (!senseLoading) {
+      senseLoading = (async () => {
+        for (const f of SENSE_FILES) {
+          if (!await ensureFile(senseDir, SENSE_REPO, f, modelHosts(), localBroadcast)) {
+            senseFailAt = Date.now() + 6e4;
+            return null;
+          }
+        }
+        senseModelReady = true;
+        return join(senseDir, SENSE_FILES[0]);
+      })().finally(() => {
+        senseLoading = null;
+      });
+    }
+    return senseLoading;
+  };
+  let senseWorker = null;
+  let senseWorkerSyncing = null;
+  const getSenseWorker = async () => {
+    if (!senseVoice()) return null;
+    if (senseWorker) return senseWorker;
+    if (senseWorkerSyncing) return senseWorkerSyncing;
+    senseWorkerSyncing = (async () => {
+      const sensePath = await ensureSenseModel();
+      if (!sensePath) return null;
+      try {
+        const workerPath = fileURLToPath(new URL("./sense-worker.mjs", import.meta.url));
+        const w = new Worker(workerPath, {
+          workerData: { sherpaModule: "sherpa-onnx", modelDir: senseDir }
+        });
+        const client = createSenseWorkerClient(w);
+        client.onDeath(() => {
+          senseWorker = null;
+          senseWorkerSyncing = null;
+        });
+        if (!await client.request("create")) {
+          await client.terminate();
+          return null;
+        }
+        senseWorker = client;
+        return client;
+      } catch (e) {
+        console.warn("[dsh-voice-mode] SenseVoice worker init failed: " + String(e));
+        return null;
+      }
+    })().finally(() => {
+      if (!senseWorker) senseWorkerSyncing = null;
+    });
+    return senseWorkerSyncing;
+  };
+  const senseTranscribe = async (allSamples) => {
+    try {
+      const worker = await getSenseWorker();
+      if (!worker) return null;
+      const total = allSamples.reduce((acc, c) => acc + c.length, 0);
+      if (total === 0) return null;
+      const buf = new Float32Array(total);
+      let off = 0;
+      for (const c of allSamples) {
+        buf.set(c, off);
+        off += c.length;
+      }
+      return await worker.request("decode", buf);
+    } catch (e) {
+      console.warn("[dsh-voice-mode] SenseVoice re-transcribe failed: " + String(e));
+      return null;
+    }
+  };
+  const feed = async (sessionId, samples, final, offset = 0, epoch = 0) => {
     const rec = await getRecognizer();
     if (!rec) return { text: "", loading: true };
-    let seg = segments.get(sessionId);
+    if (!final && senseVoice()) {
+      void getSenseWorker().catch(() => {
+      });
+    }
+    let finMap = finalized.get(sessionId);
+    const myGen = resetGen.get(sessionId) ?? 0;
+    const cached = finMap?.get(epoch);
+    if (cached !== void 0) return { text: cached };
+    let sessSegs = segments.get(sessionId);
+    if (!sessSegs) {
+      sessSegs = /* @__PURE__ */ new Map();
+      segments.set(sessionId, sessSegs);
+    }
+    let seg = sessSegs.get(epoch);
     if (!seg) {
       if (samples.length === 0 && final) return { text: "" };
-      seg = { stream: rec.createStream(), fed: 0 };
-      segments.set(sessionId, seg);
+      seg = { stream: rec.createStream(), fed: 0, vad: null, pendingEndpoint: null, lastText: "", allSamples: [], lastActivity: Date.now() };
+      sessSegs.set(epoch, seg);
+    }
+    seg.lastActivity = Date.now();
+    let endpoint = false;
+    let text = "";
+    let isSpeech;
+    if (offset + samples.length > seg.fed) {
+      const skip = Math.max(seg.fed - offset, 0);
+      const inc = samples.subarray(skip);
+      seg.stream.acceptWaveform(rec.config.featConfig.sampleRate, inc);
+      seg.fed = offset + samples.length;
+      if (seg.fed <= rec.config.featConfig.sampleRate * 60) seg.allSamples.push(inc);
+      while (rec.isReady(seg.stream)) rec.decode(seg.stream);
+      text = rec.getResult(seg.stream).text;
+      seg.lastText = text;
+      if (!final) {
+        const vad = await ensureSessionVad(seg);
+        if (vad) {
+          if (seg.pendingEndpoint) {
+            const now = Date.now();
+            const rms = rmsOf(inc);
+            if (rms > VAD_CONTINUE_RMS) {
+              seg.pendingEndpoint = null;
+            } else if (now - seg.pendingEndpoint.at >= CONFIRM_MIN_MS && text === seg.pendingEndpoint.textAtPending) {
+              seg.pendingEndpoint = null;
+              endpoint = true;
+            } else if (now - seg.pendingEndpoint.at >= seg.pendingEndpoint.confirmMs) {
+              seg.pendingEndpoint = null;
+              endpoint = true;
+            }
+          }
+          vad.acceptWaveform(inc);
+          isSpeech = vad.isDetected();
+          if (!vad.isEmpty()) {
+            let spokenMs = 0;
+            while (!vad.isEmpty()) {
+              const sp = vad.front();
+              spokenMs = sp.samples.length / 16e3 * 1e3;
+              vad.pop();
+            }
+            const confirmMs = endpointConfirmMs(seg.lastText, spokenMs);
+            if (confirmMs <= 0) {
+              endpoint = true;
+            } else {
+              seg.pendingEndpoint = { at: Date.now(), confirmMs, textAtPending: seg.lastText };
+            }
+          }
+        }
+      }
     }
-    if (samples.length > seg.fed) {
-      seg.stream.acceptWaveform(rec.config.featConfig.sampleRate, samples.subarray(seg.fed));
-      seg.fed = samples.length;
+    if (!final) return { text, endpoint, isSpeech };
+    const inflightMap = finalizing.get(sessionId);
+    const inflightP = inflightMap?.get(epoch);
+    if (inflightP) return { text: await inflightP };
+    sessSegs.delete(epoch);
+    if (sessSegs.size === 0) segments.delete(sessionId);
+    const finalizeP = (async () => {
+      const all = seg.allSamples;
+      const senseP = all.length > 0 ? Promise.race([
+        senseTranscribe(all),
+        new Promise((resolve) => setTimeout(() => resolve(null), 1e4))
+      ]) : Promise.resolve(null);
+      const pad = new Float32Array(rec.config.featConfig.sampleRate / 2);
+      seg.stream.acceptWaveform(rec.config.featConfig.sampleRate, pad);
       while (rec.isReady(seg.stream)) rec.decode(seg.stream);
+      const settled = rec.getResult(seg.stream).text;
+      try {
+        seg.vad?.free?.();
+      } catch {
+      }
+      seg.stream.free();
+      const sense = await senseP;
+      return (sense && sense.trim() ? sense : settled) || "";
+    })().then((finalText) => {
+      if ((resetGen.get(sessionId) ?? 0) !== myGen) return finalText;
+      let fm = finalized.get(sessionId);
+      if (!fm) {
+        fm = /* @__PURE__ */ new Map();
+        finalized.set(sessionId, fm);
+      }
+      fm.set(epoch, finalText);
+      if (fm.size > 32) {
+        const first = fm.keys().next().value;
+        if (first !== void 0) fm.delete(first);
+      }
+      const ff = finalizing.get(sessionId);
+      ff?.delete(epoch);
+      if (ff && ff.size === 0) finalizing.delete(sessionId);
+      return finalText;
+    }).catch((e) => {
+      const ff = finalizing.get(sessionId);
+      ff?.delete(epoch);
+      if (ff && ff.size === 0) finalizing.delete(sessionId);
+      console.warn("[dsh-voice-mode] finalize failed: " + String(e));
+      return "";
+    });
+    if (!inflightMap) {
+      finalizing.set(sessionId, /* @__PURE__ */ new Map());
+    }
+    finalizing.get(sessionId).set(epoch, finalizeP);
+    return { text: await finalizeP };
+  };
+  const sweep = () => {
+    const now = Date.now();
+    for (const [sid, sessSegs] of segments) {
+      for (const [epoch, s] of sessSegs) {
+        if (now - s.lastActivity > SEGMENT_IDLE_MS) {
+          try {
+            s.vad?.free?.();
+          } catch {
+          }
+          try {
+            s.stream.free();
+          } catch {
+          }
+          sessSegs.delete(epoch);
+        }
+      }
+      if (sessSegs.size === 0) {
+        segments.delete(sid);
+        finalized.delete(sid);
+      }
+    }
+    for (const [sid, at] of detectVadLastUse) {
+      if (now - at > SEGMENT_IDLE_MS) {
+        try {
+          detectVads.get(sid)?.free?.();
+        } catch {
+        }
+        detectVads.delete(sid);
+        detectVadLastUse.delete(sid);
+      }
+    }
+  };
+  const sweepTimer = setInterval(sweep, 3e4);
+  return {
+    feed,
+    detect: async (sessionId, samples) => {
+      const vad = await ensureDetectVad(sessionId);
+      if (!vad) return { isSpeech: false };
+      detectVadLastUse.set(sessionId, Date.now());
+      if (samples.length > 0) vad.acceptWaveform(samples);
+      const speech = vad.isDetected();
+      while (!vad.isEmpty()) vad.pop();
+      return { isSpeech: speech };
+    },
+    reset: (sessionId) => {
+      const sessSegs = segments.get(sessionId);
+      if (sessSegs) {
+        for (const [, s] of sessSegs) {
+          try {
+            s.vad?.free?.();
+          } catch {
+          }
+          try {
+            s.stream.free();
+          } catch {
+          }
+        }
+        segments.delete(sessionId);
+      }
+      finalized.delete(sessionId);
+      resetGen.set(sessionId, (resetGen.get(sessionId) ?? 0) + 1);
+      finalizing.delete(sessionId);
+      const dv = detectVads.get(sessionId);
+      if (dv) {
+        try {
+          dv.free?.();
+        } catch {
+        }
+        detectVads.delete(sessionId);
+      }
+      detectVadLastUse.delete(sessionId);
+    },
+    dispose: () => {
+      clearInterval(sweepTimer);
+      let w = senseWorker;
+      senseWorker = null;
+      senseWorkerSyncing = null;
+      if (w) void w.terminate();
+      for (const [, sessSegs] of segments) {
+        for (const [, s] of sessSegs) {
+          try {
+            s.vad?.free?.();
+          } catch {
+          }
+          try {
+            s.stream.free();
+          } catch {
+          }
+        }
+      }
+      segments.clear();
+      finalized.clear();
+      finalizing.clear();
+      resetGen.clear();
+      try {
+        recognizer?.free?.();
+      } catch {
+      }
+      recognizer = null;
+      for (const [, dv] of detectVads) {
+        try {
+          dv.free?.();
+        } catch {
+        }
+      }
+      detectVads.clear();
+      detectVadLastUse.clear();
+    },
+    modelStatus: () => {
+      const statFile = async (dir, repo, name2) => {
+        const st = await stat(join(dir, repo, name2)).catch(() => null);
+        return { exists: !!st?.isFile(), size: st?.size ?? 0 };
+      };
+      const asrFiles = MODEL_FILES.map((n) => ({
+        name: n,
+        exists: (() => {
+          try {
+            return statSync(join(repoDir, n)).isFile();
+          } catch {
+            return false;
+          }
+        })(),
+        size: (() => {
+          try {
+            return statSync(join(repoDir, n)).size;
+          } catch {
+            return 0;
+          }
+        })()
+      }));
+      const vadSize = (() => {
+        try {
+          return statSync(join(vadDir, VAD_FILES[0])).size;
+        } catch {
+          return 0;
+        }
+      })();
+      const senseSize = (() => {
+        try {
+          return statSync(join(senseDir, SENSE_FILES[0])).size;
+        } catch {
+          return 0;
+        }
+      })();
+      return {
+        // ready 语义 = 文件可用（exists），而非进程内是否已实例化——
+        // 重启后文件齐全却显示「未下载」会误导用户（体验修复）。
+        asr: {
+          repo: MODEL_REPO,
+          ready: asrFiles.every((f) => f.exists),
+          files: asrFiles,
+          failLatchMs: Math.max(0, asrFailAt - Date.now())
+        },
+        vad: {
+          repo: VAD_REPO,
+          ready: vadSize > 0,
+          size: vadSize,
+          failLatchMs: Math.max(0, vadFailAt - Date.now())
+        },
+        sense: {
+          repo: SENSE_REPO,
+          ready: senseSize > 0,
+          size: senseSize,
+          failLatchMs: Math.max(0, senseFailAt - Date.now()),
+          enabled: senseVoice()
+        },
+        progress: lastProgress
+      };
+    },
+    retryModel: async (kind) => {
+      if (kind === "vad") {
+        vadFailAt = 0;
+        return !!await ensureVadModel();
+      }
+      if (kind === "sense") {
+        if (!senseVoice()) return false;
+        senseFailAt = 0;
+        return !!await ensureSenseModel();
+      }
+      if (modelsReady) return true;
+      asrFailAt = 0;
+      return await ensureModels();
     }
-    const text = rec.getResult(seg.stream).text;
-    if (!final) return { text };
-    const pad = new Float32Array(rec.config.featConfig.sampleRate / 2);
-    seg.stream.acceptWaveform(rec.config.featConfig.sampleRate, pad);
-    while (rec.isReady(seg.stream)) rec.decode(seg.stream);
-    const settled = rec.getResult(seg.stream).text;
-    seg.stream.free();
-    segments.delete(sessionId);
-    return { text: settled };
   };
-  return { feed, reset: (sessionId) => segments.delete(sessionId) };
 }
-async function ensureFile(repoDir, file, primaryHost, broadcast) {
+async function ensureFile(repoDir, repo, file, hosts, broadcast) {
   const localPath = join(repoDir, file);
   const st = await stat(localPath).catch(() => null);
   if (st?.isFile()) return true;
   await mkdir(repoDir, { recursive: true }).catch(() => void 0);
   const partPath = `${localPath}.part`;
-  const partSt = await stat(partPath).catch(() => null);
-  const hosts = [...new Set([primaryHost, HOST_PRIMARY, HOST_FALLBACK].filter(Boolean))];
   for (const host of hosts) {
     try {
-      const ok = await download(host, repoDir, file, partSt?.size ?? 0, broadcast);
+      const cur = (await stat(partPath).catch(() => null))?.size ?? 0;
+      const ok = await download(host, repoDir, repo, file, cur, broadcast);
       if (ok) {
         await rename(partPath, localPath).catch(() => void 0);
         if ((await stat(localPath).catch(() => null))?.isFile()) return true;
@@ -120,23 +705,32 @@ async function ensureFile(repoDir, file, primaryHost, broadcast) {
 }
 var HOST_PRIMARY = "https://huggingface.co";
 var HOST_FALLBACK = "https://hf-mirror.com";
-async function download(host, repoDir, file, resumeFrom, broadcast) {
-  const url = `${host}/${MODEL_REPO}/resolve/main/${file}`;
+async function download(host, repoDir, repo, file, resumeFrom, broadcast) {
+  const url = `${host}/${repo}/resolve/main/${file}`;
   const headers = { "user-agent": "dsh-voice-mode" };
   if (resumeFrom > 0) headers.range = `bytes=${resumeFrom}-`;
-  const res = await fetch(url, { headers });
+  const res = await fetch(url, { headers, signal: AbortSignal.timeout(9e5) });
   if (res.status === 416) return true;
   if (res.status !== 200 && res.status !== 206) return false;
-  const total = Number(res.headers.get("content-length") ?? 0) + resumeFrom;
+  const resume = res.status === 206 ? resumeFrom : 0;
+  const declared = Number(res.headers.get("content-length"));
+  const total = (Number.isFinite(declared) ? declared : 0) + resume;
   const partPath = join(repoDir, `${file}.part`);
-  const sink = createWriteStream(partPath, resumeFrom > 0 ? { flags: "a" } : {});
+  const sink = createWriteStream(partPath, resume > 0 ? { flags: "a" } : {});
   const src = res.body;
   if (!src) return false;
   const reader = src.getReader();
-  let received = resumeFrom;
+  let received = resume;
   const done = new Promise((resolve, reject) => {
     sink.on("error", (e) => reject(e));
-    sink.on("finish", () => resolve(true));
+    sink.on("finish", () => {
+      if (total > 0 && received < total) {
+        sink.destroy(new Error("download truncated"));
+        reject(new Error("download truncated"));
+      } else {
+        resolve(true);
+      }
+    });
     (async () => {
       try {
         for (; ; ) {
@@ -162,6 +756,10 @@ async function download(host, repoDir, file, resumeFrom, broadcast) {
   });
   return done.catch(() => false);
 }
+var respondJson = (res, status, payload) => {
+  res.writeHead(status, { "content-type": "application/json" });
+  res.end(JSON.stringify(payload));
+};
 function handleAsrRequest(asr, activeSessionId, req, res) {
   const chunks = [];
   let received = 0;
@@ -171,45 +769,66 @@ function handleAsrRequest(asr, activeSessionId, req, res) {
     received += c.length;
     if (received > MAX_ASR_BYTES) {
       tooLarge = true;
-      res.statusCode = 413;
-      res.end(JSON.stringify({ error: "pcm payload too large" }));
+      respondJson(res, 413, { error: "pcm payload too large" });
       return;
     }
     chunks.push(c);
   });
   req.on("end", () => {
     if (tooLarge) return;
-    res.setHeader("content-type", "application/json");
     const url = new URL(req.url ?? "/", "http://localhost");
     const sessionId = url.searchParams.get("sessionId") ?? "";
     const final = url.searchParams.get("final") === "1";
     const reset = url.searchParams.get("reset") === "1";
+    const epochParam = url.searchParams.get("epoch");
+    const epochN = Number(epochParam);
+    const epochOK = epochParam === null || Number.isFinite(epochN) && epochN >= 0 && Number.isInteger(epochN);
+    const offsetParam = url.searchParams.get("offset");
+    const offsetOK = offsetParam === null || Number.isFinite(Number(offsetParam)) && Number(offsetParam) >= 0 && Number(offsetParam) <= MAX_ASR_BYTES / 4;
+    if (!offsetOK) {
+      respondJson(res, 400, { error: "invalid offset" });
+      return;
+    }
+    if (!epochOK) {
+      respondJson(res, 400, { error: "invalid epoch" });
+      return;
+    }
+    const epoch = epochParam === null ? 0 : Math.floor(epochN);
+    const offset = offsetParam === null ? 0 : Math.floor(Number(offsetParam));
     if (!sessionId || sessionId !== activeSessionId) {
-      res.statusCode = 403;
-      res.end(JSON.stringify({ error: "not the active voice session" }));
+      respondJson(res, 403, { error: "not the active voice session" });
       return;
     }
     if (reset) {
       asr.reset(sessionId);
-      res.end(JSON.stringify({ ok: true }));
+      respondJson(res, 200, { ok: true });
       return;
     }
-    const samples = pcmToSamples(Buffer.concat(chunks));
+    const raw = Buffer.concat(chunks);
+    const samples = raw.length === 0 ? final ? new Float32Array(0) : null : pcmToSamples(raw);
     if (!samples) {
-      res.statusCode = 400;
-      res.end(JSON.stringify({ error: "invalid pcm payload" }));
+      respondJson(res, 400, { error: "invalid pcm payload" });
       return;
     }
-    void asr.feed(sessionId, samples, final).then((out) => {
+    if (url.searchParams.get("vadOnly") === "1") {
+      void asr.detect(sessionId, samples).then((out) => {
+        respondJson(res, 200, { isSpeech: out.isSpeech });
+      }).catch((e) => {
+        respondJson(res, 500, { error: String(e) });
+      });
+      return;
+    }
+    void asr.feed(sessionId, samples, final, offset, epoch).then((out) => {
       if (out.loading) {
-        res.statusCode = 202;
-        res.end(JSON.stringify({ loading: true }));
+        respondJson(res, 202, { loading: true });
         return;
       }
-      res.end(JSON.stringify({ text: out.text }));
+      const body = { text: out.text };
+      if (out.endpoint) body.endpoint = true;
+      if (out.isSpeech !== void 0) body.isSpeech = out.isSpeech;
+      respondJson(res, 200, body);
     }).catch((e) => {
-      res.statusCode = 500;
-      res.end(JSON.stringify({ error: String(e) }));
+      respondJson(res, 500, { error: String(e) });
     });
   });
 }
@@ -351,6 +970,11 @@ var TtsQueue = class {
   /**
    * 弃掉某会话的所有积压并作废正在合成的句子（打断）。之后入队的句子
    * 获得新 epoch 正常播放。
+   *
+   * 打断同时重置 WebSocket 连接：pump 的 break 会 destroy 当前 audioStream（删
+   * requestId），但服务端仍在发该句残留数据——msedge-tts 的 onmessage 访问已删
+   * stream 抛 TypeError，且复用同一条 ws 会累积脏状态导致后续合成静音/失败。
+   * close 后下次 ensureReady 重建连接，干净恢复。
    */
   cancel(sessionId) {
     const q = this.queues.get(sessionId);
@@ -358,9 +982,19 @@ var TtsQueue = class {
       q.epoch++;
       q.pending.length = 0;
     }
+    this.ready = null;
+    try {
+      this.tts.close();
+    } catch {
+    }
   }
   /** 会话退出/被抢占时彻底清理其队列（防止 Map 长期累积）。 */
   prune(sessionId) {
+    const q = this.queues.get(sessionId);
+    if (q) {
+      q.epoch++;
+      q.pending.length = 0;
+    }
     this.queues.delete(sessionId);
   }
   async pump(sessionId, q) {
@@ -371,29 +1005,54 @@ var TtsQueue = class {
       while (q.pending.length > 0) {
         const item = q.pending.shift();
         try {
+          const sentenceId = q.seq++;
           const { audioStream } = this.tts.toStream(item.text, this.prosody);
-          const chunks = [];
+          let chunkId = 0;
+          let bytes = 0;
           for await (const chunk of audioStream) {
-            chunks.push(chunk);
-          }
-          const buf = Buffer.concat(chunks);
-          if (!isValidMp3(buf)) continue;
-          if (item.epoch !== q.epoch) continue;
-          q.errorNotified = false;
-          const frame = {
-            sessionId,
-            seq: q.seq++,
-            text: item.text,
-            audio: buf.toString("base64")
-          };
-          for (const fn of this.listeners) {
-            try {
-              fn(frame);
-            } catch {
+            const bin = chunk;
+            if (!bin || bin.length === 0) continue;
+            if (item.epoch !== q.epoch) break;
+            bytes += bin.length;
+            const frame = {
+              sessionId,
+              sentenceId,
+              chunkId: chunkId++,
+              final: false,
+              audio: bin.toString("base64")
+            };
+            for (const fn of this.listeners) {
+              try {
+                fn(frame);
+              } catch {
+              }
+            }
+          }
+          if (bytes > 0 && item.epoch === q.epoch) {
+            q.errorNotified = false;
+            q.backoff = 0;
+            const frame = {
+              sessionId,
+              sentenceId,
+              chunkId,
+              final: true,
+              text: item.text,
+              audio: ""
+            };
+            for (const fn of this.listeners) {
+              try {
+                fn(frame);
+              } catch {
+              }
             }
           }
         } catch (e) {
           console.warn(`[dsh-voice-mode] synthesis failed: ${String(e)}`);
+          this.ready = null;
+          try {
+            this.tts.close();
+          } catch {
+          }
         }
       }
     } catch (e) {
@@ -404,6 +1063,7 @@ var TtsQueue = class {
       }
     } finally {
       q.busy = false;
+      if (this.queues.get(sessionId) !== q) return;
       if (q.pending.length > 0) {
         const delay = q.errorNotified ? q.backoff : 0;
         q.backoff = Math.min(8e3, delay + 1e3);
@@ -422,6 +1082,10 @@ var TtsQueue = class {
 var name = "voice-mode";
 var NS_VOICE_MODE = "voice-mode";
 var BASE_PATH = "/voice-mode";
+var respondJson2 = (res, status, payload) => {
+  res.writeHead(status, { "content-type": "application/json" });
+  res.end(JSON.stringify(payload));
+};
 var VOICE_SPOKEN_PROMPT = "\u3010\u8BED\u97F3\u6A21\u5F0F\u3011\u5F53\u524D\u56DE\u590D\u4F1A\u88AB\u8BED\u97F3\u6717\u8BFB\uFF0C\u8BF7\u59CB\u7EC8\u7528\u7528\u6237\u6240\u7528\u8BED\u8A00\u3001\u4EE5\u53E3\u8BED\u5316\u7684\u77ED\u53E5\u76F4\u63A5\u56DE\u7B54\uFF0C\u50CF\u9762\u5BF9\u9762\u804A\u5929\u4E00\u6837\u81EA\u7136\uFF0C\u907F\u514D\u4E66\u9762\u8BED\u548C\u957F\u96BE\u53E5\u3002\u4E0D\u8981\u4F7F\u7528\u4EFB\u4F55 Markdown \u6216\u6392\u7248\u7B26\u53F7\uFF08\u661F\u53F7\u3001\u4E0B\u5212\u7EBF\u3001\u53CD\u5F15\u53F7\u3001\u4E95\u53F7\u3001\u5217\u8868\u4E0E\u8868\u683C\u6807\u8BB0\u3001\u4EE3\u7801\u5757\u7B49\uFF09\u3002\u9700\u8981\u5206\u70B9\u8BF4\u660E\u65F6\u7528\u300C\u7B2C\u4E00\u3001\u7B2C\u4E8C\u300D\u6216\u8FDE\u8D2F\u7684\u77ED\u53E5\u8868\u8FBE\uFF1B\u9664\u975E\u7528\u6237\u660E\u786E\u8981\u6C42\uFF0C\u4E0D\u8981\u8F93\u51FA\u4EE3\u7801\u7247\u6BB5\u3001\u5B8C\u6574 URL \u6216\u5197\u957F\u5B9A\u4E49\uFF0C\u7528\u4E00\u4E24\u53E5\u8BDD\u6982\u62EC\u542B\u4E49\u5373\u53EF\u3002\u56DE\u7B54\u7B80\u6D01\u76F4\u63A5\uFF0C\u4E0D\u8981\u91CD\u590D\u548C\u5BD2\u6684\u3002";
 var VOICE_SPOKEN_SECTION = "voice-mode:spoken-format";
 var inject = ["webServer", "settings"];
@@ -430,13 +1094,17 @@ var VOICE_SETTINGS_DEFAULTS = {
   voice: "zh-CN-XiaoxiaoNeural",
   rate: 1,
   interruptLevel: 0,
-  silenceMs: 2e3,
+  silenceMs: 700,
   idleTimeoutMinutes: 10,
   modelHost: "",
   autoSend: true,
+  autoResume: false,
   mode: "toggle",
-  wakeWord: "",
-  spokenFormat: false
+  bargeInMode: "auto",
+  echoGateDb: 6,
+  shortcut: "Ctrl+Shift+V",
+  spokenFormat: false,
+  senseVoice: true
 };
 function createVoiceSettingsSchema(defs) {
   const d = { ...VOICE_SETTINGS_DEFAULTS, ...defs };
@@ -446,13 +1114,17 @@ function createVoiceSettingsSchema(defs) {
     ),
     rate: z.number().min(0.5).max(2).default(d.rate).description("\u6717\u8BFB\u8BED\u901F\u500D\u7387\uFF080.5 = \u6162\u901F\uFF0C2.0 = \u5FEB\u901F\uFF0C1.0 = \u6B63\u5E38\uFF09"),
     interruptLevel: z.union([z.const(0), z.const(1), z.const(2)]).default(d.interruptLevel).description("\u53D1\u58F0\u6253\u65AD\u7075\u654F\u5EA6\uFF1A0 \u9AD8\u95E8\u69DB\uFF08\u5B89\u9759\u73AF\u5883\uFF0C\u9ED8\u8BA4\uFF09/ 1 \u4E2D / 2 \u4F4E\uFF08\u5608\u6742\u73AF\u5883\u66F4\u5BB9\u6613\u6253\u65AD\uFF09"),
-    silenceMs: z.number().min(500).max(3e4).default(d.silenceMs).description("\u8BF4\u5B8C\u6574\u4E00\u53E5\u7684\u9759\u97F3\u505C\u987F\u6BEB\u79D2\u6570\uFF08\u9ED8\u8BA4 2000 = 2 \u79D2\uFF09"),
+    silenceMs: z.number().min(500).max(3e4).default(d.silenceMs).description("\u8BF4\u5B8C\u6574\u4E00\u53E5\u7684\u9759\u97F3\u505C\u987F\u6BEB\u79D2\u6570\uFF08\u9ED8\u8BA4 700 \u6BEB\u79D2\uFF1B\u81F3\u5C11 250ms \u8BED\u97F3\u624D\u5224\u53E5\uFF0C\u9632\u77ED\u4FC3\u566A\u58F0\u8BEF\u89E6\u53D1\uFF09"),
     idleTimeoutMinutes: z.number().min(1).max(120).default(d.idleTimeoutMinutes).description("\u65E0\u6D3B\u52A8\u81EA\u52A8\u9000\u51FA\u8BED\u97F3\u6A21\u5F0F\u7684\u5206\u949F\u6570\uFF08\u9ED8\u8BA4 10\uFF09"),
     modelHost: z.string().default(d.modelHost).description("ASR \u6A21\u578B\u4E0B\u8F7D\u6E90\uFF08\u7559\u7A7A\u7528\u9ED8\u8BA4\u6E90\uFF1B\u56FD\u5185\u7F51\u7EDC\u53EF\u586B https://hf-mirror.com\uFF09"),
     autoSend: z.boolean().default(d.autoSend).description("\u8BC6\u522B\u5B9A\u7A3F\u540E\u81EA\u52A8\u53D1\u9001\uFF08\u5173\u95ED\u5219\u53EA\u8FDB\u8349\u7A3F\u4F9B\u7F16\u8F91\uFF1B\u6309\u4F4F Ctrl / hold \u677E\u624B\u4ECD\u4F1A\u53D1\u9001\uFF09"),
+    autoResume: z.boolean().default(d.autoResume).description("\u5207\u6362\u56DE\u4E0A\u6B21\u8BED\u97F3\u4F1A\u8BDD\u65F6\u81EA\u52A8\u6062\u590D\u8BED\u97F3\u6A21\u5F0F\uFF08\u9ED8\u8BA4\u5173\uFF0C\u9700\u9EA6\u514B\u98CE\u6743\u9650\u5DF2\u6388\u4E88\uFF1B\u5173\u95ED\u5219\u6BCF\u6B21\u5207\u6362\u4F1A\u8BDD\u540E\u9700\u91CD\u65B0\u70B9\u9EA6\u514B\u98CE\uFF09"),
     mode: z.union([z.const("toggle"), z.const("hold")]).default(d.mode).description("\u4EA4\u4E92\u6A21\u5F0F\uFF1Atoggle \u6301\u7EED\u8046\u542C + \u9759\u97F3\u81EA\u52A8\u65AD\u53E5\uFF08\u9ED8\u8BA4\uFF09\uFF1Bhold \u6309\u4F4F\u8BF4\u8BDD\u3001\u677E\u624B\u53D1\u9001\uFF08\u77ED\u6309\u9000\u51FA\uFF09"),
-    wakeWord: z.string().default(d.wakeWord).description("\u5524\u9192\u8BCD\uFF1A\u5728\u5F85\u673A\u6001\u8BF4\u51FA\u540E\u5F00\u59CB\u8BC6\u522B\uFF08\u9ED8\u8BA4\u5173\uFF1B\u5982\u300C\u4F60\u597D\u5C0FD\u300D\uFF09"),
-    spokenFormat: z.boolean().default(d.spokenFormat).description("\u8BED\u97F3\u4F1A\u8BDD\u6CE8\u5165\u53E3\u8BED\u5316\u63D0\u793A\u8BCD\uFF08\u53E3\u8BED\u5316\u77ED\u53E5\u3001\u4E0D\u7528 Markdown \u6392\u7248\u7B26\u53F7\uFF0C\u6717\u8BFB\u66F4\u987A\uFF1B\u9ED8\u8BA4\u5173\uFF0C\u6539\u52A8\u5373\u65F6\u751F\u6548\uFF09")
+    bargeInMode: z.union([z.const("auto"), z.const("manual")]).default(d.bargeInMode).description("\u6253\u65AD\u65B9\u5F0F\uFF1Aauto \u81EA\u52A8\u6253\u65AD\uFF08\u5F00\u53E3\u5373\u6253\u65AD\uFF0C\u8033\u673A/\u5B89\u9759\u73AF\u5883\u63A8\u8350\uFF09\uFF1Bmanual \u624B\u52A8\u6253\u65AD\uFF08\u5916\u653E\u63A8\u8350\u2014\u2014\u5916\u653E\u56DE\u58F0\u4F1A\u8BEF\u89E6\u53D1\u81EA\u52A8\u6253\u65AD\uFF0C\u6539\u6309\u4F4F\u9EA6\u514B\u98CE/Ctrl \u663E\u5F0F\u6253\u65AD\uFF0C\u6C38\u4E0D\u81EA\u6253\u65AD\uFF09"),
+    echoGateDb: z.number().min(3).max(12).default(d.echoGateDb).description("\u56DE\u58F0\u95E8\u63A7\u9608\u503C\uFF08dB\uFF0C\u9ED8\u8BA4 6\uFF09\uFF1A\u81EA\u52A8\u6253\u65AD\u8981\u6C42\u6B8B\u5DEE\u9AD8\u4E8E\u56DE\u58F0\u5730\u677F\u6B64\u503C\uFF1B\u5916\u653E\u4ECD\u8BEF\u6253\u65AD\u8C03\u5927\uFF088~10\uFF09\uFF0C\u592A\u96BE\u6253\u65AD\u8C03\u5C0F\uFF083~4\uFF09"),
+    shortcut: z.string().default(d.shortcut).description("\u8FDB\u5165/\u9000\u51FA\u8BED\u97F3\u6A21\u5F0F\u7684\u5FEB\u6377\u952E\uFF08\u5F62\u5982 Ctrl+Shift+V\uFF0C\u4FEE\u9970\u952E Ctrl/Shift/Alt/Meta + \u4E00\u4E2A\u5B57\u6BCD\u952E\uFF1B\u7559\u7A7A\u7981\u7528\u5FEB\u6377\u952E\uFF0C\u7528\u9EA6\u514B\u98CE\u6309\u94AE\uFF09"),
+    spokenFormat: z.boolean().default(d.spokenFormat).description("\u8BED\u97F3\u4F1A\u8BDD\u6CE8\u5165\u53E3\u8BED\u5316\u63D0\u793A\u8BCD\uFF08\u53E3\u8BED\u5316\u77ED\u53E5\u3001\u4E0D\u7528 Markdown \u6392\u7248\u7B26\u53F7\uFF0C\u6717\u8BFB\u66F4\u987A\uFF1B\u9ED8\u8BA4\u5173\uFF0C\u6539\u52A8\u5373\u65F6\u751F\u6548\uFF09"),
+    senseVoice: z.boolean().default(d.senseVoice).description("\u5B9A\u7A3F\u7528 SenseVoice \u91CD\u8BD1\uFF08\u5E26\u6807\u70B9+\u6570\u5B57\u5F52\u4E00\u5316\u3001\u8BC6\u522B\u66F4\u51C6\uFF1B\u9ED8\u8BA4\u5F00\u3002\u5173\u95ED\u53EF\u7701 228MB \u6A21\u578B\uFF0C\u53EA\u8D70\u6D41\u5F0F\u8BC6\u522B\uFF09")
   });
 }
 var VoiceSettingsSchema = createVoiceSettingsSchema();
@@ -463,16 +1135,26 @@ var Config = z.object({
   voice: z.string().default("zh-CN-XiaoxiaoNeural"),
   rate: z.number().default(1),
   interruptLevel: z.union([z.const(0), z.const(1), z.const(2)]).default(0),
-  silenceMs: z.number().default(2e3),
+  silenceMs: z.number().default(700),
   idleTimeoutMinutes: z.number().default(10)
 });
 function apply(ctx, config) {
   let activeVoiceSession = null;
+  let activeTabId = null;
+  let ownerYieldTimer = null;
+  const turnStates = /* @__PURE__ */ new Map();
+  const setTurn = (sessionId, state) => {
+    if (turnStates.get(sessionId) === state) return;
+    turnStates.set(sessionId, state);
+    broadcast("turn", { sessionId, state });
+  };
+  const turnGen = /* @__PURE__ */ new Map();
   const sseClients = /* @__PURE__ */ new Set();
+  const latestConnByTab = /* @__PURE__ */ new Map();
   const broadcast = (event, payload) => {
-    for (const send of sseClients) {
+    for (const c of sseClients) {
       try {
-        send(event, payload);
+        c.send(event, payload);
       } catch {
       }
     }
@@ -495,8 +1177,11 @@ function apply(ctx, config) {
   const asr = createAsrRuntime({
     cacheDir: config.cacheDir,
     modelHost: () => vset.modelHost,
+    // P4：SenseVoice 定稿重译开关（实时读取，关闭则不下载/不创建模型）。
+    senseVoice: () => vset.senseVoice,
     broadcast
   });
+  ctx.effect(() => () => asr.dispose());
   const queue = new TtsQueue({
     voice: vset.voice,
     rate: vset.rate,
@@ -514,6 +1199,19 @@ function apply(ctx, config) {
   const currentVoice = () => vset.voice;
   const currentRate = () => vset.rate;
   const currentInterrupt = () => vset.interruptLevel;
+  const yieldActiveSession = (expectedSid) => {
+    ownerYieldTimer = null;
+    const sid = activeVoiceSession;
+    if (!sid) return;
+    if (expectedSid !== void 0 && expectedSid !== sid) return;
+    activeVoiceSession = null;
+    activeTabId = null;
+    queue.cancel(sid);
+    asr.reset(sid);
+    setTurn(sid, "idle");
+    turnStates.delete(sid);
+    broadcast("mode", { active: null, ownerTabId: activeTabId });
+  };
   ctx.on("system-prompt/assemble", (assembly, context, next) => {
     if (!config.enabled || !vset.spokenFormat) return next();
     const agentId = context.agent?.id;
@@ -526,7 +1224,17 @@ function apply(ctx, config) {
     const sessionId = options.sessionId;
     if (!config.enabled || sessionId === void 0 || options.purpose !== void 0) return next();
     if (activeVoiceSession !== sessionId) return next();
-    return tapActiveStream(sessionId, next(), queue, broadcast);
+    const gen = (turnGen.get(sessionId) ?? 0) + 1;
+    turnGen.set(sessionId, gen);
+    return tapActiveStream(
+      sessionId,
+      next(),
+      queue,
+      broadcast,
+      (state) => {
+        if ((turnGen.get(sessionId) ?? 0) === gen) setTurn(sessionId, state);
+      }
+    );
   });
   const base = BASE_PATH;
   ctx.effect(
@@ -534,16 +1242,12 @@ function apply(ctx, config) {
       kind: "prefix",
       path: base,
       handler: (_req, res) => {
-        res.statusCode = 200;
-        res.setHeader("content-type", "application/json");
-        res.end(
-          JSON.stringify({
-            ok: true,
-            name: "dsh-voice-mode",
-            enabled: config.enabled,
-            active: activeVoiceSession
-          })
-        );
+        respondJson2(res, 200, {
+          ok: true,
+          name: "dsh-voice-mode",
+          enabled: config.enabled,
+          active: activeVoiceSession
+        });
       }
     })
   );
@@ -552,23 +1256,23 @@ function apply(ctx, config) {
       kind: "exact",
       path: `${base}/config`,
       handler: (_req, res) => {
-        res.statusCode = 200;
-        res.setHeader("content-type", "application/json");
-        res.end(
-          JSON.stringify({
-            basePath: base,
-            rate: currentRate(),
-            voice: currentVoice(),
-            interruptLevel: currentInterrupt(),
-            silenceMs: vset.silenceMs,
-            idleTimeoutMinutes: vset.idleTimeoutMinutes,
-            modelHost: vset.modelHost,
-            autoSend: vset.autoSend,
-            mode: vset.mode,
-            wakeWord: vset.wakeWord,
-            cacheDir: config.cacheDir
-          })
-        );
+        respondJson2(res, 200, {
+          basePath: base,
+          rate: currentRate(),
+          voice: currentVoice(),
+          senseVoice: vset.senseVoice,
+          interruptLevel: currentInterrupt(),
+          silenceMs: vset.silenceMs,
+          idleTimeoutMinutes: vset.idleTimeoutMinutes,
+          modelHost: vset.modelHost,
+          autoSend: vset.autoSend,
+          autoResume: vset.autoResume,
+          mode: vset.mode,
+          bargeInMode: vset.bargeInMode,
+          echoGateDb: vset.echoGateDb,
+          shortcut: vset.shortcut,
+          cacheDir: config.cacheDir
+        });
       }
     })
   );
@@ -578,9 +1282,7 @@ function apply(ctx, config) {
       path: `${base}/preview`,
       handler: (req, res) => {
         if (!config.enabled) {
-          res.statusCode = 403;
-          res.setHeader("content-type", "application/json");
-          res.end(JSON.stringify({ error: "voice mode disabled" }));
+          respondJson2(res, 403, { error: "voice mode disabled" });
           return;
         }
         collectBody(req, res, MAX_JSON_BODY, async (body) => {
@@ -595,15 +1297,11 @@ function apply(ctx, config) {
           } catch {
           }
           if (voice.length > 128) {
-            res.statusCode = 400;
-            res.setHeader("content-type", "application/json");
-            res.end(JSON.stringify({ error: "voice too long" }));
+            respondJson2(res, 400, { error: "voice too long" });
             return;
           }
           if (!voice) {
-            res.statusCode = 400;
-            res.setHeader("content-type", "application/json");
-            res.end(JSON.stringify({ error: "voice required" }));
+            respondJson2(res, 400, { error: "voice required" });
             return;
           }
           const sample = voice.startsWith("zh-") ? "\u4F60\u597D\uFF0C\u6B22\u8FCE\u4F7F\u7528\u8BED\u97F3\u6A21\u5F0F\u3002" : "Hello, welcome to voice mode.";
@@ -612,14 +1310,10 @@ function apply(ctx, config) {
             buf = await queue.synthesize(sample, { voice, rate });
           } catch (e) {
             console.warn(`[dsh-voice-mode] preview synthesis failed: ${String(e)}`);
-            res.statusCode = 502;
-            res.setHeader("content-type", "application/json");
-            res.end(JSON.stringify({ error: "\u9884\u89C8\u5408\u6210\u5931\u8D25\uFF1A\u8BF7\u68C0\u67E5\u7F51\u7EDC\u6216\u97F3\u8272\u540D\uFF08ShortName\uFF09\u662F\u5426\u6B63\u786E" }));
+            respondJson2(res, 502, { error: "\u9884\u89C8\u5408\u6210\u5931\u8D25\uFF1A\u8BF7\u68C0\u67E5\u7F51\u7EDC\u6216\u97F3\u8272\u540D\uFF08ShortName\uFF09\u662F\u5426\u6B63\u786E" });
             return;
           }
-          res.statusCode = 200;
-          res.setHeader("content-type", "audio/mpeg");
-          res.setHeader("cache-control", "no-store");
+          res.writeHead(200, { "content-type": "audio/mpeg", "cache-control": "no-store" });
           res.end(buf);
         });
       }
@@ -633,36 +1327,99 @@ function apply(ctx, config) {
         collectBody(req, res, MAX_JSON_BODY, (body) => {
           let sessionId;
           let on;
+          let tabId;
           try {
             const parsed = JSON.parse(body || "{}");
             sessionId = parsed.sessionId;
             on = parsed.on;
+            tabId = typeof parsed.tabId === "string" && parsed.tabId.length <= 64 ? parsed.tabId : void 0;
           } catch {
           }
           if (!sessionId) {
-            res.statusCode = 400;
-            res.end(JSON.stringify({ error: "sessionId required" }));
+            respondJson2(res, 400, { error: "sessionId required" });
+            return;
+          }
+          if (on !== void 0 && typeof on !== "boolean") {
+            respondJson2(res, 400, { error: "invalid on" });
             return;
           }
           if (on === true) {
             if (!config.enabled) {
-              res.statusCode = 403;
-              res.end(JSON.stringify({ error: "voice mode disabled" }));
+              respondJson2(res, 403, { error: "voice mode disabled" });
               return;
             }
+            asr.reset(sessionId);
+            queue.cancel(sessionId);
             const previous = activeVoiceSession;
             activeVoiceSession = sessionId;
-            if (previous && previous !== sessionId) queue.prune(previous);
-            broadcast("mode", { active: activeVoiceSession });
+            activeTabId = tabId ?? null;
+            if (ownerYieldTimer) {
+              clearTimeout(ownerYieldTimer);
+              ownerYieldTimer = null;
+            }
+            if (previous && previous !== sessionId) {
+              queue.cancel(previous);
+              asr.reset(previous);
+              setTurn(previous, "idle");
+              turnStates.delete(previous);
+            }
+            broadcast("mode", { active: activeVoiceSession, ownerTabId: activeTabId });
           } else {
             if (activeVoiceSession === sessionId) {
               activeVoiceSession = null;
-              queue.prune(sessionId);
-              broadcast("mode", { active: null });
+              activeTabId = null;
+              if (ownerYieldTimer) {
+                clearTimeout(ownerYieldTimer);
+                ownerYieldTimer = null;
+              }
+              queue.cancel(sessionId);
+              asr.reset(sessionId);
+              setTurn(sessionId, "idle");
+              turnStates.delete(sessionId);
+              broadcast("mode", { active: null, ownerTabId: null });
             }
           }
-          res.setHeader("content-type", "application/json");
-          res.end(JSON.stringify({ active: activeVoiceSession }));
+          respondJson2(res, 200, { active: activeVoiceSession });
+        });
+      }
+    })
+  );
+  ctx.effect(
+    () => ctx.webServer.register({
+      kind: "exact",
+      path: `${base}/models/status`,
+      handler: (_req, res) => {
+        respondJson2(res, 200, asr.modelStatus());
+      }
+    })
+  );
+  ctx.effect(
+    () => ctx.webServer.register({
+      kind: "exact",
+      path: `${base}/models/retry`,
+      handler: (req, res) => {
+        if (!config.enabled) {
+          respondJson2(res, 403, { error: "voice mode disabled" });
+          return;
+        }
+        collectBody(req, res, MAX_JSON_BODY, (body) => {
+          let kind = "asr";
+          try {
+            const p = JSON.parse(body || "{}");
+            if (p.kind === void 0) {
+            } else if (p.kind === "vad" || p.kind === "sense" || p.kind === "asr") {
+              kind = p.kind;
+            } else {
+              respondJson2(res, 400, { error: "invalid kind" });
+              return;
+            }
+          } catch {
+            respondJson2(res, 400, { error: "invalid json" });
+            return;
+          }
+          void asr.retryModel(kind).then((done) => {
+            respondJson2(res, 200, { ok: done, kind });
+          });
         });
       }
     })
@@ -672,6 +1429,14 @@ function apply(ctx, config) {
       kind: "exact",
       path: `${base}/asr`,
       handler: (req, res) => {
+        try {
+          const url = new URL(req.url ?? "/", "http://localhost");
+          const sid = url.searchParams.get("sessionId") ?? "";
+          if (sid && sid === activeVoiceSession) {
+            setTurn(sid, url.searchParams.get("final") === "1" ? "finalizing" : "listening");
+          }
+        } catch {
+        }
         handleAsrRequest(asr, activeVoiceSession, req, res);
       }
     })
@@ -683,17 +1448,18 @@ function apply(ctx, config) {
       handler: (req, res) => {
         collectBody(req, res, MAX_JSON_BODY, (body) => {
           let sessionId;
+          let keepAsr = false;
           try {
             const parsed = JSON.parse(body || "{}");
             sessionId = parsed.sessionId;
+            keepAsr = parsed.keepAsr === true;
           } catch {
           }
-          if (sessionId) {
+          if (sessionId && sessionId === activeVoiceSession) {
             queue.cancel(sessionId);
-            asr.reset(sessionId);
+            if (!keepAsr) asr.reset(sessionId);
           }
-          res.setHeader("content-type", "application/json");
-          res.end(JSON.stringify({ ok: true }));
+          respondJson2(res, 200, { ok: true });
         });
       }
     })
@@ -702,7 +1468,14 @@ function apply(ctx, config) {
     () => ctx.webServer.register({
       kind: "exact",
       path: `${base}/stream`,
-      handler: (_req, res) => {
+      handler: (req, res) => {
+        let tabId = null;
+        try {
+          const u = new URL(req.url ?? "/", "http://localhost");
+          tabId = u.searchParams.get("tabId");
+        } catch {
+        }
+        if (tabId !== null && tabId.length > 64) tabId = null;
         res.writeHead(200, {
           "content-type": "text/event-stream; charset=utf-8",
           "cache-control": "no-cache, no-transform",
@@ -715,16 +1488,35 @@ data: ${JSON.stringify(payload)}
 
 `);
         };
-        sseClients.add(send);
-        send("mode", { active: activeVoiceSession });
+        const client = { tabId, send };
+        sseClients.add(client);
+        if (tabId !== null) latestConnByTab.set(tabId, client);
+        if (tabId !== null && tabId === activeTabId && ownerYieldTimer) {
+          clearTimeout(ownerYieldTimer);
+          ownerYieldTimer = null;
+        }
+        send("mode", { active: activeVoiceSession, ownerTabId: activeTabId });
         const heartbeat = setInterval(() => {
-          res.write(": hb\n");
+          try {
+            res.write(": hb\n");
+          } catch {
+          }
         }, 25e3);
+        let cleaned = false;
         const cleanup = () => {
+          if (cleaned) return;
+          cleaned = true;
           clearInterval(heartbeat);
-          sseClients.delete(send);
+          sseClients.delete(client);
+          if (tabId !== null && latestConnByTab.get(tabId) === client) {
+            latestConnByTab.delete(tabId);
+            if (tabId === activeTabId) {
+              if (ownerYieldTimer) clearTimeout(ownerYieldTimer);
+              ownerYieldTimer = setTimeout(() => yieldActiveSession(activeVoiceSession), 8e3);
+            }
+          }
         };
-        _req.on("close", cleanup);
+        req.on("close", cleanup);
         res.on("close", cleanup);
       }
     })
@@ -732,20 +1524,22 @@ data: ${JSON.stringify(payload)}
 }
 var MAX_JSON_BODY = 16 * 1024;
 function collectBody(req, res, maxBytes, onBody) {
-  let body = "";
+  const chunks = [];
+  let received = 0;
   let tooLarge = false;
   req.on("data", (c) => {
     if (tooLarge) return;
-    body += c;
-    if (body.length > maxBytes) {
+    received += c.length;
+    if (received > maxBytes) {
       tooLarge = true;
-      res.statusCode = 413;
-      res.setHeader("content-type", "application/json");
-      res.end(JSON.stringify({ error: "request body too large" }));
+      respondJson2(res, 413, { error: "request body too large" });
+      return;
     }
+    chunks.push(c);
   });
   req.on("end", () => {
     if (tooLarge) return;
+    const body = Buffer.concat(chunks).toString("utf8");
     try {
       const r = onBody(body);
       if (r && typeof r.then === "function") r.catch(() => {
@@ -756,8 +1550,10 @@ function collectBody(req, res, maxBytes, onBody) {
   req.on("error", () => {
   });
 }
-async function* tapActiveStream(sessionId, inner, queue, broadcast) {
+async function* tapActiveStream(sessionId, inner, queue, broadcast, onTurn) {
   const segmenter = new SentenceSegmenter();
+  let firstTokenBroadcast = false;
+  let firstSentenceBroadcast = false;
   let flushed = false;
   let finishReason = null;
   const flushOnce = () => {
@@ -770,13 +1566,19 @@ async function* tapActiveStream(sessionId, inner, queue, broadcast) {
   try {
     for await (const chunk of inner) {
       if (chunk.type === "text-delta" && chunk.text) {
+        if (!firstTokenBroadcast) {
+          firstTokenBroadcast = true;
+          broadcast("latency", { sessionId, stage: "first-llm-token" });
+          onTurn("agent-speaking");
+        }
         for (const s of segmenter.feed(chunk.text)) {
+          if (!firstSentenceBroadcast) {
+            firstSentenceBroadcast = true;
+            broadcast("latency", { sessionId, stage: "first-sentence-text" });
+          }
           queue.enqueue(sessionId, s);
         }
       }
-      if (chunk.type === "tool-call-delta" && chunk.name) {
-        broadcast("tool", { sessionId, name: chunk.name });
-      }
       if (chunk.type === "finish") {
         finishReason = chunk.reason;
       }
@@ -785,6 +1587,7 @@ async function* tapActiveStream(sessionId, inner, queue, broadcast) {
   } finally {
     const aborted = finishReason !== null && typeof finishReason === "object" && finishReason.kind === "aborted";
     if (!aborted) flushOnce();
+    onTurn("listening");
   }
 }
 export {