omnius 1.0.420 → 1.0.422

package/dist/scripts/live-whisper.py

@@ -129,6 +129,44 @@ import numpy as np
 # Main transcription loop
 # ---------------------------------------------------------------------------
 
+def _norm_tokens(text):
+    """Normalize a transcript for cross-model comparison: lowercase, strip
+    punctuation, collapse whitespace, drop empty tokens."""
+    import re
+    return [t for t in re.sub(r"[^\w\s]", " ", text.lower()).split() if t]
+
+
+def _texts_agree(a: str, b: str, threshold: float) -> bool:
+    """Consensus check between two model transcripts. Real speech produces
+    similar output from different whisper models; hallucinations on noise are
+    high-variance and virtually never match across models."""
+    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
+    import difflib
+    return difflib.SequenceMatcher(None, ta, tb).ratio() >= threshold
+
+
+def _segment_filtered_text(result) -> str:
+    """Rebuild transcript from segments, dropping low-confidence and
+    likely-non-speech segments (classic hallucination carriers)."""
+    segments = result.get("segments") or []
+    if not segments:
+        return result.get("text", "").strip()
+    kept = []
+    for seg in segments:
+        if float(seg.get("no_speech_prob", 0.0)) > 0.6:
+            continue
+        if float(seg.get("avg_logprob", 0.0)) < -1.2:
+            continue
+        kept.append(str(seg.get("text", "")))
+    return " ".join(part.strip() for part in kept if part.strip()).strip()
+
+
 def main():
     import argparse
     parser = argparse.ArgumentParser(description="Live Whisper transcription worker")
@@ -136,6 +174,10 @@ def main():
     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("--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.")
+    parser.add_argument("--consensus-threshold", type=float, default=0.55,
+                        help="Token similarity (0-1) required between the two models' transcripts.")
     args = parser.parse_args()
 
     import whisper
@@ -156,6 +198,19 @@ def main():
         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
+    # quiet audio) don't reproduce across models, so disagreement = reject.
+    consensus_model = None
+    consensus_name = (args.consensus_model or "off").strip().lower()
+    if consensus_name not in ("off", "none", "", args.model):
+        emit_status(f"Loading consensus Whisper {consensus_name} model...")
+        try:
+            consensus_model = whisper.load_model(consensus_name, device=device)
+        except Exception as e:
+            emit_status(f"Consensus model unavailable ({e}); running single-model.")
+            consensus_model = None
+
     emit({"type": "ready"})
 
     # Audio buffer — accumulates PCM16 as float32 @ 16kHz
@@ -235,17 +290,48 @@ def main():
             # Amplify toward full scale before transcription
             window = amplify(window)
 
-            # Transcribe
+            # 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")
-                result = model.transcribe(
-                    window,
-                    fp16=fp16,
-                    language=args.language,
-                    no_speech_threshold=0.6,
-                    condition_on_previous_text=False,
-                )
-                text = result.get("text", "").strip()
+
+                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)
@@ -270,7 +356,7 @@ def main():
                 fp16=fp16,
                 language=args.language,
             )
-            text = result.get("text", "").strip()
+            text = _segment_filtered_text(result)
             if text:
                 emit_transcript(text, is_final=True)
         except Exception:

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "omnius",
-  "version": "1.0.420",
+  "version": "1.0.422",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "omnius",
-      "version": "1.0.420",
+      "version": "1.0.422",
       "bundleDependencies": [
         "image-to-ascii"
       ],
@@ -2505,9 +2505,9 @@
       }
     },
     "node_modules/bare-fs": {
-      "version": "4.7.2",
-      "resolved": "https://registry.npmjs.org/bare-fs/-/bare-fs-4.7.2.tgz",
-      "integrity": "sha512-aTvMFUWkBmjzKtEQMDGGDNF8bkfpD5N1b/FCwt7A3wrU4t1o/e/85Wzkluh6JlODCjqVESYCkQCdTXqZ9G7VFg==",
+      "version": "4.7.3",
+      "resolved": "https://registry.npmjs.org/bare-fs/-/bare-fs-4.7.3.tgz",
+      "integrity": "sha512-xRgplks8SvcKkdlv2M6Z2LZmRsmqd+x0nXXGXeMEjwdibj1HSDrlnqBRLeYdMvsgCox7Bq0e+DHwfczOfsn6IA==",
       "license": "Apache-2.0",
       "optional": true,
       "dependencies": {

package/package.json

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