omnius 1.0.443 → 1.0.445

package/dist/scripts/live-whisper.py

@@ -14,8 +14,8 @@ Architecture (EGG voice/whisper lineage):
     (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.
+  - Optional dual-model consensus: a second whisper model can validate
+    finalized utterances when explicitly enabled.
 
 Protocol:
   stdin  — raw PCM16 audio (16kHz, mono, 16-bit signed LE)
@@ -58,6 +58,23 @@ SAMPLE_WIDTH = 2  # 16-bit
 BLOCK_SECONDS = 0.2
 BLOCK_SAMPLES = int(SAMPLE_RATE * BLOCK_SECONDS)
 
+
+def env_float(name: str, default: float) -> float:
+    raw = os.environ.get(name, "").strip()
+    if not raw:
+        return default
+    try:
+        return float(raw)
+    except ValueError:
+        return default
+
+
+def env_bool(name: str, default: bool = False) -> bool:
+    raw = os.environ.get(name, "").strip().lower()
+    if not raw:
+        return default
+    return raw in ("1", "true", "yes", "on", "enabled")
+
 # ---------------------------------------------------------------------------
 # Output helpers (JSON lines to stdout)
 # ---------------------------------------------------------------------------
@@ -450,7 +467,7 @@ def main():
     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",
+    parser.add_argument("--consensus-model", default="off",
                         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.")
@@ -460,6 +477,18 @@ def main():
                         help="Audio kept from before speech onset.")
     parser.add_argument("--max-utterance-seconds", type=float, default=22,
                         help="Force-finalize utterances longer than this.")
+    parser.add_argument("--partials", action="store_true", default=env_bool("OMNIUS_ASR_PARTIALS", False),
+                        help="Emit interim Whisper transcripts during long utterances. Disabled by default to avoid silence/noise hallucinations.")
+    parser.add_argument("--min-speech-ms", type=float, default=env_float("OMNIUS_ASR_MIN_SPEECH_MS", 450.0),
+                        help="Minimum VAD-positive speech duration required before an utterance is sent to Whisper.")
+    parser.add_argument("--start-rms", type=float, default=env_float("OMNIUS_ASR_START_RMS", 0.0025),
+                        help="Minimum block RMS required for software VAD speech start.")
+    parser.add_argument("--energy-ratio", type=float, default=env_float("OMNIUS_ASR_ENERGY_RATIO", 3.5),
+                        help="Software VAD speech gate as a multiple of the adaptive noise floor.")
+    parser.add_argument("--min-utterance-rms", type=float, default=env_float("OMNIUS_ASR_MIN_UTTERANCE_RMS", 0.003),
+                        help="Minimum loud-block RMS required before final transcription.")
+    parser.add_argument("--min-utterance-peak", type=float, default=env_float("OMNIUS_ASR_MIN_UTTERANCE_PEAK", 0.015),
+                        help="Minimum utterance peak amplitude required when RMS is low.")
     args = parser.parse_args()
 
     import whisper
@@ -543,6 +572,9 @@ def main():
     utterance = []       # list of float32 blocks while capturing
     capturing = False
     silence_run = 0
+    speech_blocks = 0
+    utterance_rms_values = []
+    utterance_peak = 0.0
     noise_floor = None
     last_partial_at = 0.0
     last_final_text = ""
@@ -558,7 +590,7 @@ def main():
             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
+        gate = max(float(args.start_rms), noise_floor * float(args.energy_ratio))
         return block_rms >= gate
 
     def transcribe_partial(samples):
@@ -574,9 +606,31 @@ def main():
         except Exception as e:
             emit_error(f"Transcription error: {e}")
 
-    def transcribe_final(samples):
-        nonlocal last_final_text
+    def utterance_quality_ok(samples, speech_block_count, rms_values, peak) -> bool:
         if len(samples) < int(0.4 * SAMPLE_RATE):
+            return False
+        speech_ms = speech_block_count * BLOCK_SECONDS * 1000.0
+        if speech_ms < float(args.min_speech_ms):
+            if env_bool("OMNIUS_ASR_VERBOSE_VAD", False):
+                emit_status(f"Dropped short VAD blob before Whisper: speech_ms={speech_ms:.0f}")
+            return False
+        if rms_values:
+            ordered = sorted(float(v) for v in rms_values)
+            loud_half = ordered[len(ordered) // 2:] or ordered
+            loud_rms = loud_half[len(loud_half) // 2]
+        else:
+            loud_rms = float(np.sqrt(np.mean(samples ** 2))) if len(samples) else 0.0
+        if loud_rms < float(args.min_utterance_rms) and peak < float(args.min_utterance_peak):
+            if env_bool("OMNIUS_ASR_VERBOSE_VAD", False):
+                emit_status(
+                    f"Dropped low-energy VAD blob before Whisper: loud_rms={loud_rms:.5f} peak={peak:.5f}"
+                )
+            return False
+        return True
+
+    def transcribe_final(samples, speech_block_count=0, rms_values=None, peak=0.0):
+        nonlocal last_final_text
+        if not utterance_quality_ok(samples, speech_block_count, rms_values or [], peak):
             return
         samples = amplify(samples)
         try:
@@ -612,7 +666,9 @@ def main():
                     last_final_text = primary_text
                     emit_transcript(primary_text, is_final=True, doa=primary_doa, consensus=True)
                 except Exception as e:
-                    emit_error(f"Consensus validation error: {e}")
+                    emit_consensus_rejected(primary_text, "", "validator_error")
+                    if env_bool("OMNIUS_ASR_VERBOSE_CONSENSUS", False):
+                        emit_status(f"Consensus validation error: {e}")
 
             threading.Thread(
                 target=validate_consensus,
@@ -664,12 +720,18 @@ def main():
                     if speech:
                         capturing = True
                         silence_run = 0
+                        speech_blocks = 1
+                        utterance_rms_values = [block_rms]
+                        utterance_peak = float(np.max(np.abs(block))) if len(block) else 0.0
                         utterance = list(preroll)
                         preroll.clear()
                     continue
 
                 utterance.append(block)
+                utterance_rms_values.append(block_rms)
+                utterance_peak = max(utterance_peak, float(np.max(np.abs(block))) if len(block) else 0.0)
                 if speech:
+                    speech_blocks += 1
                     silence_run = 0
                 else:
                     silence_run += 1
@@ -677,11 +739,17 @@ def main():
                 utter_samples = sum(len(b) for b in utterance)
                 if silence_run >= finalize_blocks or utter_samples >= max_utter_samples:
                     samples = np.concatenate(utterance)
+                    final_speech_blocks = speech_blocks
+                    final_rms_values = list(utterance_rms_values)
+                    final_peak = utterance_peak
                     capturing = False
                     utterance = []
                     silence_run = 0
-                    transcribe_final(samples)
-                elif utter_samples >= int(3.5 * SAMPLE_RATE) and now - last_partial_at >= 2.5:
+                    speech_blocks = 0
+                    utterance_rms_values = []
+                    utterance_peak = 0.0
+                    transcribe_final(samples, final_speech_blocks, final_rms_values, final_peak)
+                elif args.partials and 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:
@@ -690,7 +758,12 @@ def main():
     # EOF: finalize any in-flight utterance.
     if utterance:
         try:
-            transcribe_final(np.concatenate(utterance))
+            transcribe_final(
+                np.concatenate(utterance),
+                speech_blocks,
+                list(utterance_rms_values),
+                utterance_peak,
+            )
         except Exception:
             pass
     if tuning is not None:

package/npm-shrinkwrap.json

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

package/package.json

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