omnius 1.0.423 → 1.0.425

package/dist/scripts/live-whisper.py

@@ -5,30 +5,42 @@ live-whisper.py — Self-contained live transcription worker using openai-whispe
 Fallback for transcribe-cli on platforms where faster-whisper / ONNX fails
 (e.g. linux-arm64). Auto-creates a Python venv and installs openai-whisper.
 
+Architecture (EGG voice/whisper lineage):
+  - Utterance-chunked transcription: speech-start → sustained silence →
+    transcribe the COMPLETE utterance once. No sliding-window re-transcription
+    (which duplicated partials, fed whisper silence-heavy windows, and
+    hallucinated on quiet audio).
+  - ReSpeaker hardware VAD/AEC/DOA: when a ReSpeaker 4-Mic array is present
+    (USB 2886:0018), the XMOS DSP's SPEECHDETECTED register gates utterances,
+    on-chip echo cancellation is enabled, and the DOA angle is attached to
+    transcripts. Falls back to adaptive energy VAD otherwise.
+  - Dual-model consensus: a second whisper model transcribes finalized
+    utterances in parallel; transcripts are only emitted when both agree.
+
 Protocol:
   stdin  — raw PCM16 audio (16kHz, mono, 16-bit signed LE)
   stdout — JSON lines:
     {"type":"status","message":"Installing dependencies..."}
     {"type":"status","message":"Loading model..."}
     {"type":"ready"}
+    {"type":"vad","speech":true,"doa":90}
     {"type":"transcript","text":"hello world","isFinal":false}
-    {"type":"transcript","text":"hello world how are you","isFinal":true}
+    {"type":"transcript","text":"hello world how are you","isFinal":true,"doa":90}
+    {"type":"consensus_rejected","primary":"...","secondary":"...","reason":"..."}
     {"type":"error","message":"..."}
 
 Usage:
   arecord -f S16_LE -r 16000 -c 1 -t raw -q - | python3 live-whisper.py --model base
-
-Based on the proven ARM-compatible approach from hydra/whisper_asr.
 """
 
 import sys
 import os
 import json
 import subprocess
-import importlib
 import struct
 import time
 import threading
+from collections import deque
 from pathlib import Path
 
 # ---------------------------------------------------------------------------
@@ -43,8 +55,8 @@ PIP = VENV / "bin" / "pip"
 SAMPLE_RATE = 16000
 CHANNELS = 1
 SAMPLE_WIDTH = 2  # 16-bit
-CHUNK_SECONDS = 3  # Transcribe every N seconds of audio
-WINDOW_SECONDS = 10  # Transcribe last N seconds (sliding window)
+BLOCK_SECONDS = 0.2
+BLOCK_SAMPLES = int(SAMPLE_RATE * BLOCK_SECONDS)
 
 # ---------------------------------------------------------------------------
 # Output helpers (JSON lines to stdout)
@@ -64,11 +76,14 @@ def emit_error(msg: str):
     emit({"type": "error", "message": msg})
 
 
-def emit_transcript(text: str, is_final: bool = False):
-    emit({"type": "transcript", "text": text, "isFinal": is_final})
+def emit_transcript(text: str, is_final: bool = False, doa=None):
+    event = {"type": "transcript", "text": text, "isFinal": is_final}
+    if doa is not None:
+        event["doa"] = doa
+    emit(event)
 
 # ---------------------------------------------------------------------------
-# Venv bootstrap (inspired by hydra/whisper_asr)
+# Venv bootstrap
 # ---------------------------------------------------------------------------
 
 def _in_venv() -> bool:
@@ -81,7 +96,6 @@ def _ensure_venv():
     emit_status("Creating Python venv for Whisper...")
     import venv
     venv.EnvBuilder(with_pip=True).create(str(VENV))
-    # Upgrade pip quietly
     subprocess.check_call(
         [str(PY), "-m", "pip", "install", "--upgrade", "pip"],
         stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
@@ -106,27 +120,132 @@ def _ensure_deps():
             [str(PIP), "install", *need],
             stdout=subprocess.DEVNULL, stderr=subprocess.PIPE,
         )
-        # Force reimport
         for mod in ["numpy", "whisper"]:
             if mod in sys.modules:
                 del sys.modules[mod]
 
+    # pyusb is optional — only needed for ReSpeaker DSP tuning (hardware
+    # VAD/AEC/DOA). Failure is tolerated; we fall back to energy VAD.
+    try:
+        import usb.core  # noqa: F401
+    except ImportError:
+        try:
+            subprocess.check_call(
+                [str(PIP), "install", "pyusb"],
+                stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
+            )
+        except Exception:
+            pass
+
 # ---------------------------------------------------------------------------
 # Bootstrap: ensure we're in the venv with deps
 # ---------------------------------------------------------------------------
 
 if not _in_venv():
     _ensure_venv()
-    # Re-exec this script inside the venv
     os.execv(str(PY), [str(PY)] + sys.argv)
 
 _ensure_deps()
 
-# Now safe to import
 import numpy as np
 
 # ---------------------------------------------------------------------------
-# Main transcription loop
+# ReSpeaker DSP tuning (EGG voice/whisper lineage)
+# ---------------------------------------------------------------------------
+#
+# The ReSpeaker 4-Mic array (USB 2886:0018) exposes its XMOS DSP over USB
+# vendor control transfers. The on-chip beamformed VAD (SPEECHDETECTED) is far
+# more robust than software energy gating on quiet capture chains, the echo
+# canceller stops TTS playback from leaking into ASR, and DOAANGLE localizes
+# the speaker.
+
+RESPEAKER_PARAMS = {
+    "SPEECHDETECTED":  (19, 22, "int"),
+    "DOAANGLE":        (21, 0,  "int"),
+    "AECFREEZEONOFF":  (18, 7,  "int"),
+    "AECSILENCELEVEL": (18, 30, "float"),
+    "ECHOONOFF":       (19, 14, "int"),
+}
+
+
+class ReSpeakerTuning:
+    TIMEOUT = 1000  # ms — polled every block; must never stall the FSM
+
+    def __init__(self, dev, usb_util):
+        self.dev = dev
+        self.usb_util = usb_util
+        self.failures = 0
+
+    def write(self, name, value):
+        param_id, offset, kind = RESPEAKER_PARAMS[name]
+        if kind == "int":
+            payload = struct.pack(b"iii", offset, int(value), 1)
+        else:
+            payload = struct.pack(b"ifi", offset, float(value), 0)
+        self.dev.ctrl_transfer(0x40, 0, 0, param_id, payload, self.TIMEOUT)
+
+    def read(self, name):
+        param_id, offset, kind = RESPEAKER_PARAMS[name]
+        cmd = 0x80 | offset
+        if kind == "int":
+            cmd |= 0x40
+        response = self.dev.ctrl_transfer(0xC0, 0, cmd, param_id, 8, self.TIMEOUT)
+        low, high = struct.unpack(b"ii", response.tobytes())
+        return low if kind == "int" else low * (2.0 ** high)
+
+    def speech_detected(self):
+        """True/False from the DSP VAD, or None when the read fails."""
+        try:
+            value = self.read("SPEECHDETECTED")
+            self.failures = 0
+            return bool(value)
+        except Exception:
+            self.failures += 1
+            return None
+
+    def doa(self):
+        try:
+            return int(self.read("DOAANGLE"))
+        except Exception:
+            return None
+
+    def close(self):
+        try:
+            self.usb_util.dispose_resources(self.dev)
+        except Exception:
+            pass
+
+
+def find_respeaker():
+    """Locate the ReSpeaker array and enable on-chip echo cancellation."""
+    try:
+        import usb.core
+        import usb.util
+    except ImportError:
+        return None
+    try:
+        dev = usb.core.find(idVendor=0x2886, idProduct=0x0018)
+        if dev is None:
+            return None
+        tuning = ReSpeakerTuning(dev, usb.util)
+        # EGG-recommended AEC settings: adaptive echo canceller on, echo
+        # suppression on, raised silence level to mask self-generated audio.
+        try:
+            tuning.write("AECFREEZEONOFF", 0)
+            tuning.write("ECHOONOFF", 1)
+            tuning.write("AECSILENCELEVEL", 1e-4)
+        except Exception:
+            pass  # tuning writes need udev permissions; VAD reads may still work
+        # Probe the VAD once — if it doesn't answer, don't use the device.
+        if tuning.speech_detected() is None:
+            tuning.close()
+            return None
+        return tuning
+    except Exception:
+        return None
+
+# ---------------------------------------------------------------------------
+# Transcript quality helpers
 # ---------------------------------------------------------------------------
 
 def _norm_tokens(text):
@@ -143,7 +262,6 @@ def _texts_agree(a: str, b: str, threshold: float) -> bool:
     ta, tb = _norm_tokens(a), _norm_tokens(b)
     if not ta or not tb:
         return False
-    # Containment: short utterances often differ only by dropped filler words
     ja, jb = " ".join(ta), " ".join(tb)
     if ja in jb or jb in ja:
         return True
@@ -167,22 +285,63 @@ def _segment_filtered_text(result) -> str:
     return " ".join(part.strip() for part in kept if part.strip()).strip()
 
 
+def amplify(samples):
+    """Bring quiet-but-real speech toward a healthy level for whisper.
+
+    Gain targets the SPEECH RMS (median of the loudest half of 0.2s blocks),
+    not the raw peak — a single click/pop no longer suppresses amplification
+    of otherwise-quiet speech. Gain is capped at 40x (~32dB) and bounded so
+    the peak never clips."""
+    if len(samples) == 0:
+        return samples
+    peak = float(np.max(np.abs(samples)))
+    if peak <= 0:
+        return samples
+    block = max(1, SAMPLE_RATE // 5)
+    energies = sorted(
+        float(np.sqrt(np.mean(samples[i:i + block] ** 2)))
+        for i in range(0, max(1, len(samples) - block + 1), block)
+    )
+    loud_half = energies[len(energies) // 2:] or energies
+    speech_rms = loud_half[len(loud_half) // 2]  # median of the loud half
+    target_rms = 0.08  # ≈ -22dBFS — comfortable whisper input level
+    if speech_rms >= target_rms:
+        return samples
+    # No-clip bound uses the 99th-percentile amplitude, not the absolute
+    # peak — an isolated click/pop may clip (harmless to ASR) instead of
+    # suppressing amplification of the actual speech.
+    p99 = float(np.percentile(np.abs(samples), 99.0))
+    gain = min(40.0, target_rms / max(speech_rms, 1e-5), 0.98 / max(p99, 1e-4))
+    if gain <= 1.05:
+        return samples
+    return np.clip(samples * gain, -1.0, 1.0)
+
+# ---------------------------------------------------------------------------
+# Main transcription loop — utterance FSM
+# ---------------------------------------------------------------------------
+
 def main():
     import argparse
     parser = argparse.ArgumentParser(description="Live Whisper transcription worker")
-    parser.add_argument("--model", default="base", help="Whisper model size (tiny/base/small/medium/large)")
-    parser.add_argument("--chunk-seconds", type=float, default=CHUNK_SECONDS, help="Transcribe interval")
-    parser.add_argument("--window-seconds", type=float, default=WINDOW_SECONDS, help="Sliding window size")
+    parser.add_argument("--model", default="medium", help="Whisper model size (tiny/base/small/medium/large)")
+    # Accepted for backward compatibility with older launchers (sliding-window era).
+    parser.add_argument("--chunk-seconds", type=float, default=3, help=argparse.SUPPRESS)
+    parser.add_argument("--window-seconds", type=float, default=10, help=argparse.SUPPRESS)
     parser.add_argument("--language", default=None, help="Language code (e.g. en, es, fr). Auto-detect if omitted.")
     parser.add_argument("--consensus-model", default="tiny",
-                        help="Second whisper model run in parallel on the same audio; transcripts are only emitted when both models agree. 'off' disables.")
+                        help="Second whisper model run in parallel on finalized utterances; transcripts are only emitted when both models agree. 'off' disables.")
     parser.add_argument("--consensus-threshold", type=float, default=0.55,
                         help="Token similarity (0-1) required between the two models' transcripts.")
+    parser.add_argument("--silence-ms", type=float, default=900,
+                        help="Sustained silence that finalizes an utterance.")
+    parser.add_argument("--preroll-ms", type=float, default=600,
+                        help="Audio kept from before speech onset.")
+    parser.add_argument("--max-utterance-seconds", type=float, default=22,
+                        help="Force-finalize utterances longer than this.")
     args = parser.parse_args()
 
     import whisper
 
-    # Load model
     emit_status(f"Loading Whisper {args.model} model...")
     try:
         device = "cpu"
@@ -192,14 +351,12 @@ def main():
                 device = "cuda"
         except ImportError:
             pass
-
         model = whisper.load_model(args.model, device=device)
     except Exception as e:
         emit_error(f"Failed to load model: {e}")
         sys.exit(1)
 
-    # Consensus model: a second (usually smaller) model transcribes the same
-    # window in parallel. Hallucinations (mixed-language garbage on noisy or
+    # Consensus model: hallucinations (mixed-language garbage on noisy or
     # quiet audio) don't reproduce across models, so disagreement = reject.
     consensus_model = None
     consensus_name = (args.consensus_model or "off").strip().lower()
@@ -211,43 +368,36 @@ def main():
             emit_status(f"Consensus model unavailable ({e}); running single-model.")
             consensus_model = None
 
+    # ReSpeaker DSP: hardware VAD + echo cancellation + DOA
+    tuning = find_respeaker()
+    if tuning is not None:
+        emit_status("ReSpeaker DSP active: hardware VAD, echo cancellation, DOA.")
+
     emit({"type": "ready"})
 
-    # Audio buffer — accumulates PCM16 as float32 @ 16kHz
+    fp16 = (device == "cuda")
+
+    def run_transcribe(m, samples):
+        return m.transcribe(
+            samples,
+            fp16=fp16,
+            language=args.language,
+            no_speech_threshold=0.6,
+            condition_on_previous_text=False,
+        )
+
+    # Shared PCM intake
     audio_buf = np.zeros(0, dtype=np.float32)
     buf_lock = threading.Lock()
-    chunk_bytes = int(args.chunk_seconds * SAMPLE_RATE * SAMPLE_WIDTH)
-    window_samples = int(args.window_seconds * SAMPLE_RATE)
-    last_text = ""
     running = True
-    noise_floor = None  # EMA of the quietest 0.5s block RMS — adapts to the capture chain
-
-    def block_energies(samples):
-        """RMS of consecutive 0.5s blocks — lets speech anywhere in the
-        window register even when most of the window is silence."""
-        block = SAMPLE_RATE // 2
-        n = max(1, len(samples) // block)
-        return [float(np.sqrt(np.mean(samples[i * block:(i + 1) * block] ** 2))) for i in range(n)]
-
-    def amplify(samples):
-        """Bring quiet-but-real speech toward full scale. Whisper performs far
-        better near normal levels; quiet capture chains (distant speakers,
-        low source gain, beamformed arrays) otherwise force users to shout
-        into the mic. Gain capped at 40x (~32dB), output clipped to [-1, 1]."""
-        peak = float(np.max(np.abs(samples))) if len(samples) else 0.0
-        if 0 < peak < 0.5:
-            samples = np.clip(samples * min(40.0, 0.9 / max(peak, 1e-4)), -1.0, 1.0)
-        return samples
 
     def read_stdin():
-        """Read PCM16 from stdin in a background thread."""
         nonlocal audio_buf, running
         try:
             while running:
-                data = sys.stdin.buffer.read(chunk_bytes)
+                data = sys.stdin.buffer.read(BLOCK_SAMPLES * SAMPLE_WIDTH)
                 if not data:
                     break  # EOF
-                # Convert PCM16 LE to float32 [-1, 1]
                 samples = np.frombuffer(data, dtype=np.int16).astype(np.float32) / 32768.0
                 with buf_lock:
                     audio_buf = np.concatenate([audio_buf, samples])
@@ -256,112 +406,158 @@ def main():
         finally:
             running = False
 
-    # Start stdin reader thread
     reader = threading.Thread(target=read_stdin, daemon=True)
     reader.start()
 
+    # Utterance FSM state
+    preroll_blocks = max(1, int(round(args.preroll_ms / 1000.0 / BLOCK_SECONDS)))
+    finalize_blocks = max(2, int(round(args.silence_ms / 1000.0 / BLOCK_SECONDS)))
+    max_utter_samples = int(args.max_utterance_seconds * SAMPLE_RATE)
+
+    preroll = deque(maxlen=preroll_blocks)
+    utterance = []       # list of float32 blocks while capturing
+    capturing = False
+    silence_run = 0
+    noise_floor = None
+    last_partial_at = 0.0
+    last_final_text = ""
+    last_vad_emit = (False, 0.0)
+    pending = np.zeros(0, dtype=np.float32)
+    cursor = 0
+
+    def energy_speech(block_rms):
+        nonlocal noise_floor
+        if noise_floor is None:
+            noise_floor = block_rms
+        elif block_rms < noise_floor:
+            noise_floor = 0.7 * noise_floor + 0.3 * block_rms  # drop fast
+        else:
+            noise_floor = 0.995 * noise_floor + 0.005 * block_rms  # creep up slowly
+        gate = max(1.5e-4, noise_floor * 2.5)  # ≥ ~8dB above floor
+        return block_rms >= gate
+
+    def transcribe_partial(samples):
+        try:
+            result = run_transcribe(model, amplify(samples))
+            text = _segment_filtered_text(result)
+            if text:
+                emit_transcript(text, is_final=False)
+        except Exception as e:
+            emit_error(f"Transcription error: {e}")
+
+    def transcribe_final(samples):
+        nonlocal last_final_text
+        if len(samples) < int(0.4 * SAMPLE_RATE):
+            return
+        samples = amplify(samples)
+        try:
+            if consensus_model is not None:
+                from concurrent.futures import ThreadPoolExecutor
+                with ThreadPoolExecutor(max_workers=2) as pool:
+                    primary_future = pool.submit(run_transcribe, model, samples)
+                    secondary_future = pool.submit(run_transcribe, consensus_model, samples)
+                    result = primary_future.result()
+                    secondary = secondary_future.result()
+            else:
+                result = run_transcribe(model, samples)
+                secondary = None
+
+            text = _segment_filtered_text(result)
+            if not text:
+                return
+            if secondary is not None:
+                secondary_text = _segment_filtered_text(secondary)
+                lang_a = str(result.get("language", "")).lower()
+                lang_b = str(secondary.get("language", "")).lower()
+                lang_disagree = bool(lang_a and lang_b and lang_a != lang_b and not args.language)
+                if lang_disagree or not _texts_agree(text, secondary_text, args.consensus_threshold):
+                    emit({
+                        "type": "consensus_rejected",
+                        "primary": text[:200],
+                        "secondary": (secondary_text or "")[:200],
+                        "reason": "language_mismatch" if lang_disagree else "low_similarity",
+                    })
+                    return
+            if text == last_final_text:
+                return
+            last_final_text = text
+            emit_transcript(text, is_final=True, doa=tuning.doa() if tuning else None)
+        except Exception as e:
+            emit_error(f"Transcription error: {e}")
+
     try:
         while running:
-            time.sleep(args.chunk_seconds)
+            time.sleep(BLOCK_SECONDS / 2)
 
             with buf_lock:
-                if len(audio_buf) < SAMPLE_RATE:  # Need at least 1s of audio
+                if len(audio_buf) > cursor:
+                    pending = np.concatenate([pending, audio_buf[cursor:]])
+                    cursor = len(audio_buf)
+                # Bound memory: keep the buffer from growing without limit.
+                if len(audio_buf) > 120 * SAMPLE_RATE:
+                    audio_buf = audio_buf[-SAMPLE_RATE:]
+                    cursor = len(audio_buf)
+
+            while len(pending) >= BLOCK_SAMPLES:
+                block = pending[:BLOCK_SAMPLES]
+                pending = pending[BLOCK_SAMPLES:]
+
+                block_rms = float(np.sqrt(np.mean(block ** 2)))
+                energy = energy_speech(block_rms)
+                hw = tuning.speech_detected() if tuning is not None else None
+                if tuning is not None and tuning.failures > 5:
+                    # Repeated USB read failures (unplug, permission loss) —
+                    # stop polling so control-transfer timeouts can't stall
+                    # the FSM; energy VAD takes over.
+                    emit_status("ReSpeaker DSP unresponsive — falling back to energy VAD.")
+                    tuning.close()
+                    tuning = None
+                    hw = None
+                # Hardware VAD is authoritative when the DSP answers; energy
+                # VAD covers non-ReSpeaker mics and USB read failures.
+                speech = hw if hw is not None else energy
+
+                now = time.time()
+                if speech != last_vad_emit[0] and now - last_vad_emit[1] > 0.3:
+                    last_vad_emit = (speech, now)
+                    emit({"type": "vad", "speech": bool(speech), "doa": tuning.doa() if tuning else None})
+
+                if not capturing:
+                    preroll.append(block)
+                    if speech:
+                        capturing = True
+                        silence_run = 0
+                        utterance = list(preroll)
+                        preroll.clear()
                     continue
-                # Take the last window_seconds of audio
-                window = audio_buf[-window_samples:].copy() if len(audio_buf) > window_samples else audio_buf.copy()
-
-            # Adaptive silence gate: whisper hallucinates repetitive garbage
-            # on silent input, but absolute thresholds reject real speech on
-            # quiet capture chains. Instead track the noise floor (quietest
-            # 0.5s block) and require the loudest block to rise above it.
-            energies = block_energies(window)
-            quiet = min(energies)
-            loud = max(energies)
-            if noise_floor is None:
-                noise_floor = quiet
-            elif quiet < noise_floor:
-                noise_floor = 0.7 * noise_floor + 0.3 * quiet  # drop fast
-            else:
-                noise_floor = 0.995 * noise_floor + 0.005 * quiet  # creep up slowly
-            gate = max(1.5e-4, noise_floor * 2.5)  # ≥ ~8dB above floor, ~-76dB min
-            if loud < gate:
-                continue
-
-            # Amplify toward full scale before transcription
-            window = amplify(window)
-
-            # Transcribe — primary and consensus models in parallel threads
-            # (torch releases the GIL during compute, so this is real
-            # parallelism on multicore ARM).
-            try:
-                fp16 = (device == "cuda")
-
-                def run_transcribe(m):
-                    return m.transcribe(
-                        window,
-                        fp16=fp16,
-                        language=args.language,
-                        no_speech_threshold=0.6,
-                        condition_on_previous_text=False,
-                    )
-
-                if consensus_model is not None:
-                    from concurrent.futures import ThreadPoolExecutor
-                    with ThreadPoolExecutor(max_workers=2) as pool:
-                        primary_future = pool.submit(run_transcribe, model)
-                        secondary_future = pool.submit(run_transcribe, consensus_model)
-                        result = primary_future.result()
-                        secondary = secondary_future.result()
-                else:
-                    result = run_transcribe(model)
-                    secondary = None
-
-                text = _segment_filtered_text(result)
-
-                if text and secondary is not None:
-                    secondary_text = _segment_filtered_text(secondary)
-                    lang_a = str(result.get("language", "")).lower()
-                    lang_b = str(secondary.get("language", "")).lower()
-                    lang_disagree = bool(lang_a and lang_b and lang_a != lang_b and not args.language)
-                    if lang_disagree or not _texts_agree(text, secondary_text, args.consensus_threshold):
-                        emit({
-                            "type": "consensus_rejected",
-                            "primary": text[:200],
-                            "secondary": (secondary_text or "")[:200],
-                            "reason": "language_mismatch" if lang_disagree else "low_similarity",
-                        })
-                        continue
-
-                if text and text != last_text:
-                    last_text = text
-                    emit_transcript(text, is_final=False)
-            except Exception as e:
-                emit_error(f"Transcription error: {e}")
 
+                utterance.append(block)
+                if speech:
+                    silence_run = 0
+                else:
+                    silence_run += 1
+
+                utter_samples = sum(len(b) for b in utterance)
+                if silence_run >= finalize_blocks or utter_samples >= max_utter_samples:
+                    samples = np.concatenate(utterance)
+                    capturing = False
+                    utterance = []
+                    silence_run = 0
+                    transcribe_final(samples)
+                elif utter_samples >= int(3.5 * SAMPLE_RATE) and now - last_partial_at >= 2.5:
+                    last_partial_at = now
+                    transcribe_partial(np.concatenate(utterance))
     except KeyboardInterrupt:
         pass
 
-    # Final transcription of the full buffer
-    with buf_lock:
-        full_audio = audio_buf.copy()
-
-    final_loud = max(block_energies(full_audio)) if len(full_audio) >= SAMPLE_RATE else 0.0
-    final_gate = max(1.5e-4, (noise_floor or 0.0) * 2.5)
-    if len(full_audio) >= SAMPLE_RATE and final_loud >= final_gate:
+    # EOF: finalize any in-flight utterance.
+    if utterance:
         try:
-            full_audio = amplify(full_audio)
-            fp16 = (device == "cuda")
-            result = model.transcribe(
-                full_audio,
-                fp16=fp16,
-                language=args.language,
-            )
-            text = _segment_filtered_text(result)
-            if text:
-                emit_transcript(text, is_final=True)
+            transcribe_final(np.concatenate(utterance))
         except Exception:
             pass
-
+    if tuning is not None:
+        tuning.close()
     running = False
 
 

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "omnius",
-  "version": "1.0.423",
+  "version": "1.0.425",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "omnius",
-      "version": "1.0.423",
+      "version": "1.0.425",
       "bundleDependencies": [
         "image-to-ascii"
       ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omnius",
-  "version": "1.0.423",
+  "version": "1.0.425",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",