omnius 1.0.430 → 1.0.431

package/dist/index.js

@@ -330392,7 +330392,7 @@ ${lanes.join("\n")}
           }
           return false;
         }
-        function createPropertyDescriptor(attributes, singleLine) {
+        function createPropertyDescriptor(attributes, singleLine2) {
           const properties = [];
           tryAddPropertyAssignment(properties, "enumerable", asExpression(attributes.enumerable));
           tryAddPropertyAssignment(properties, "configurable", asExpression(attributes.configurable));
@@ -330401,7 +330401,7 @@ ${lanes.join("\n")}
           let isAccessor2 = tryAddPropertyAssignment(properties, "get", attributes.get);
           isAccessor2 = tryAddPropertyAssignment(properties, "set", attributes.set) || isAccessor2;
           Debug.assert(!(isData && isAccessor2), "A PropertyDescriptor may not be both an accessor descriptor and a data descriptor.");
-          return createObjectLiteralExpression(properties, !singleLine);
+          return createObjectLiteralExpression(properties, !singleLine2);
         }
         function updateOuterExpression(outerExpression, expression) {
           switch (outerExpression.kind) {
@@ -343871,9 +343871,9 @@ ${lanes.join("\n")}
           }
           return;
         }
-        const singleLine = range.kind === 2 && singleLinePragmaRegEx.exec(text2);
-        if (singleLine) {
-          return addPragmaForMatch(pragmas, range, 2, singleLine);
+        const singleLine2 = range.kind === 2 && singleLinePragmaRegEx.exec(text2);
+        if (singleLine2) {
+          return addPragmaForMatch(pragmas, range, 2, singleLine2);
         }
         if (range.kind === 3) {
           const multiLinePragmaRegEx = /@(\S+)(\s+(?:\S.*)?)?$/gm;
@@ -419394,7 +419394,7 @@ ${lanes.join("\n")}
         }
         function transformFunctionBody2(node) {
           let multiLine = false;
-          let singleLine = false;
+          let singleLine2 = false;
           let statementsLocation;
           let closeBraceLocation;
           const prologue = [];
@@ -419436,7 +419436,7 @@ ${lanes.join("\n")}
             const equalsGreaterThanToken = node.equalsGreaterThanToken;
             if (!nodeIsSynthesized(equalsGreaterThanToken) && !nodeIsSynthesized(body)) {
               if (rangeEndIsOnSameLineAsRangeStart(equalsGreaterThanToken, body, currentSourceFile)) {
-                singleLine = true;
+                singleLine2 = true;
               } else {
                 multiLine = true;
               }
@@ -419465,7 +419465,7 @@ ${lanes.join("\n")}
           }
           const block = factory2.createBlock(setTextRange(factory2.createNodeArray(statements), statementsLocation), multiLine);
           setTextRange(block, node.body);
-          if (!multiLine && singleLine) {
+          if (!multiLine && singleLine2) {
             setEmitFlags(
               block,
               1
@@ -603393,6 +603393,10 @@ function defaultConsensusModel(primaryModel) {
   if (model === "large-v3" || model === "large") return "small";
   return "base";
 }
+function asrConsensusEnabled() {
+  const consensusEnv = String(process.env["OMNIUS_ASR_CONSENSUS"] ?? "").trim().toLowerCase();
+  return !(consensusEnv === "0" || consensusEnv === "off" || consensusEnv === "false");
+}
 async function ensureVenvForTranscribeCli() {
   const bin = process.platform === "win32" ? "Scripts" : "bin";
   const exe = process.platform === "win32" ? "python.exe" : "python3";
@@ -603895,8 +603899,19 @@ var init_listen = __esm({
           updateListenLiveState({ phase: "error", lastStatus: "no mic capture tool (arecord/sox/ffmpeg)" });
           return "No microphone capture tool found. Install arecord (Linux), sox (macOS), or ffmpeg.";
         }
-        let tc = await this.loadTranscribeCli();
-        if (!tc) {
+        const preferWhisperFallback = asrConsensusEnabled();
+        if (preferWhisperFallback) {
+          this.emit(
+            "info",
+            "ASR consensus enabled — using live-whisper.py (CUDA when available)."
+          );
+          updateListenLiveState({
+            backend: "openai-whisper",
+            lastStatus: "starting consensus Whisper backend..."
+          });
+        }
+        let tc = preferWhisperFallback ? null : await this.loadTranscribeCli();
+        if (!preferWhisperFallback && !tc) {
           if (_bgInstallPromise) {
             this.emit("info", "Waiting for transcribe-cli install...");
             await _bgInstallPromise;
@@ -604174,13 +604189,14 @@ transcribe-cli error: ${transcribeCliError}` : "";
        * Caller is responsible for calling .stop() when done.
        */
       async createCallTranscriber() {
-        let tc = await this.loadTranscribeCli();
-        if (!tc && _bgInstallPromise) {
+        const requireConsensus = asrConsensusEnabled();
+        let tc = requireConsensus ? null : await this.loadTranscribeCli();
+        if (!requireConsensus && !tc && _bgInstallPromise) {
           await _bgInstallPromise;
           this.transcribeCliAvailable = null;
           tc = await this.loadTranscribeCli();
         }
-        if (!tc) {
+        if (!requireConsensus && !tc) {
           try {
             await ensureManagedTranscribeCliNode();
             this.transcribeCliAvailable = null;
@@ -604188,7 +604204,7 @@ transcribe-cli error: ${transcribeCliError}` : "";
           } catch {
           }
         }
-        if (tc?.TranscribeLive && await ensureVenvForTranscribeCli()) {
+        if (!requireConsensus && tc?.TranscribeLive && await ensureVenvForTranscribeCli()) {
           try {
             const transcriber = new tc.TranscribeLive({
               model: this.config.model,
@@ -617275,6 +617291,7 @@ let micStream = null;
 let scriptProcessor = null;
 let micActive = false;
 let playbackQueue = [];
+let pendingTtsHeader = null;
 let isPlaying = false;
 let reconnectDelay = 1000;
 let reconnectTimer = null;
@@ -617334,10 +617351,14 @@ function connect() {
           waveState = 'speaking';
         } else if (msg.type === 'speaking_end') {
           waveState = micActive ? 'listening' : 'idle';
+        } else if (msg.type === 'tts_header') {
+          pendingTtsHeader = { sampleRate: msg.sampleRate || 22050 };
         }
       } catch {}
     } else {
-      playbackQueue.push(new Int16Array(evt.data));
+      const sampleRate = (pendingTtsHeader && pendingTtsHeader.sampleRate) || 22050;
+      pendingTtsHeader = null;
+      playbackQueue.push({ pcm: new Int16Array(evt.data), sampleRate });
       if (!isPlaying) drainPlayback();
     }
   };
@@ -617356,15 +617377,17 @@ function escapeHtml(s) {
 }
 
 async function drainPlayback() {
-  if (!playbackCtx) playbackCtx = new AudioContext({ sampleRate: 22050 });
+  if (!playbackCtx) playbackCtx = new AudioContext();
   isPlaying = true;
   while (playbackQueue.length > 0) {
-    const int16 = playbackQueue.shift();
+    const frame = playbackQueue.shift();
+    const int16 = frame.pcm || frame;
+    const sampleRate = frame.sampleRate || 22050;
     const float32 = new Float32Array(int16.length);
     for (let i = 0; i < int16.length; i++) {
       float32[i] = int16[i] < 0 ? int16[i] / 0x8000 : int16[i] / 0x7FFF;
     }
-    const buf = playbackCtx.createBuffer(1, float32.length, 22050);
+    const buf = playbackCtx.createBuffer(1, float32.length, sampleRate);
     buf.getChannelData(0).set(float32);
     const src = playbackCtx.createBufferSource();
     src.buffer = buf;
@@ -618013,11 +618036,15 @@ var init_voice_session = __esm({
       /**
        * Send TTS audio (PCM Int16 @ model sample rate) to all connected clients.
        */
-      sendAudioToClients(pcmInt16) {
+      sendAudioToClients(pcmInt16, sampleRate = 22050) {
         this.ttsSpeaking = true;
+        const header = JSON.stringify({ type: "tts_header", sampleRate, bytes: pcmInt16.length });
         for (const ws of this.wsClients.values()) {
           try {
-            if (ws.readyState === import_websocket5.default.OPEN) ws.send(pcmInt16);
+            if (ws.readyState === import_websocket5.default.OPEN) {
+              ws.send(header);
+              ws.send(pcmInt16);
+            }
           } catch {
           }
         }
@@ -618025,11 +618052,15 @@ var init_voice_session = __esm({
       /**
        * Send TTS audio to a specific client by clientId.
        */
-      sendAudioToClient(clientId, pcmInt16) {
+      sendAudioToClient(clientId, pcmInt16, sampleRate = 22050) {
+        this.ttsSpeaking = true;
         const ws = this.wsClients.get(clientId);
         if (ws) {
           try {
-            if (ws.readyState === import_websocket5.default.OPEN) ws.send(pcmInt16);
+            if (ws.readyState === import_websocket5.default.OPEN) {
+              ws.send(JSON.stringify({ type: "tts_header", sampleRate, bytes: pcmInt16.length }));
+              ws.send(pcmInt16);
+            }
           } catch {
           }
         }
@@ -618038,6 +618069,7 @@ var init_voice_session = __esm({
        * Send speaking state change to a specific client.
        */
       sendSpeakingStateToClient(clientId, speaking) {
+        this.ttsSpeaking = speaking;
         const ws = this.wsClients.get(clientId);
         if (ws) {
           const msg = JSON.stringify({ type: speaking ? "speaking_start" : "speaking_end" });
@@ -673216,6 +673248,147 @@ var init_emotion_engine = __esm({
   }
 });
 
+// packages/cli/src/tui/conversation-context.ts
+import { statfsSync as statfsSync8 } from "node:fs";
+function buildConversationRuntimeContext(now2 = /* @__PURE__ */ new Date(), repoRoot) {
+  const date = new Intl.DateTimeFormat("en-US", {
+    weekday: "long",
+    year: "numeric",
+    month: "long",
+    day: "numeric"
+  }).format(now2);
+  const time = new Intl.DateTimeFormat("en-US", {
+    hour: "numeric",
+    minute: "2-digit",
+    second: "2-digit",
+    timeZoneName: "short"
+  }).format(now2);
+  const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone || process.env["TZ"] || "system";
+  let diskLine = "";
+  if (repoRoot) {
+    try {
+      const stats = statfsSync8(repoRoot);
+      const totalBytes = Number(stats.blocks) * Number(stats.bsize);
+      const freeBytes = Number(stats.bavail) * Number(stats.bsize);
+      const usedBytes = totalBytes - freeBytes;
+      const totalGB = Math.round(totalBytes / 1024 ** 3);
+      const freeGB = Math.round(freeBytes / 1024 ** 3);
+      const usedGB = Math.round(usedBytes / 1024 ** 3);
+      const usedPct = totalBytes > 0 ? Math.round(usedBytes / totalBytes * 100) : 0;
+      diskLine = `Disk: disk_available_gb=${freeGB} disk_used_gb=${usedGB} disk_total_gb=${totalGB} disk_used_pct=${usedPct} path=${repoRoot}`;
+    } catch {
+    }
+  }
+  return [
+    `Current date: ${date}`,
+    `Current time: ${time}`,
+    `Current ISO timestamp: ${now2.toISOString()}`,
+    `Timezone: ${timezone}`,
+    repoRoot ? `Working directory: ${repoRoot}` : "",
+    diskLine
+  ].filter(Boolean).join("\n");
+}
+function quoteConversationBlock(value2, maxChars = 2400) {
+  const text2 = String(value2 ?? "").replace(/\r\n/g, "\n").trim();
+  if (!text2) return "> (empty)";
+  const clipped = text2.length > maxChars ? `${text2.slice(0, Math.max(0, maxChars - 1))}...` : text2;
+  return clipped.split("\n").map((line) => `> ${line}`).join("\n");
+}
+function buildScopedConversationMessages(turns, options2) {
+  const pinned = [];
+  const dynamic = [];
+  let latestContextFrame = null;
+  for (const turn of turns) {
+    if (options2.isPinnedSystemTurn(turn) && !pinned.some((p2) => p2.content === turn.content)) {
+      pinned.push(turn);
+    } else if (options2.isContextFrameTurn?.(turn)) {
+      latestContextFrame = turn;
+    } else {
+      dynamic.push(turn);
+    }
+  }
+  if (latestContextFrame) {
+    if (options2.placeContextFrameBeforeLastUser !== false) {
+      let lastUserIdx = -1;
+      for (let i2 = dynamic.length - 1; i2 >= 0; i2--) {
+        if (dynamic[i2].role === "user") {
+          lastUserIdx = i2;
+          break;
+        }
+      }
+      if (lastUserIdx >= 0) dynamic.splice(lastUserIdx, 0, latestContextFrame);
+      else dynamic.push(latestContextFrame);
+    } else {
+      dynamic.push(latestContextFrame);
+    }
+  }
+  const available = Math.max(0, options2.maxMessages - pinned.length);
+  let windowed = dynamic.slice(-available);
+  if (latestContextFrame && available > 0 && !windowed.includes(latestContextFrame)) {
+    windowed = [latestContextFrame, ...windowed.slice(-(available - 1))];
+  }
+  return [...pinned, ...windowed];
+}
+function buildVoiceSessionContext(args) {
+  const maxTranscriptTurns = Math.max(1, args.maxTranscriptTurns ?? 8);
+  const voiceLines = (args.voiceTranscript ?? []).slice(-maxTranscriptTurns).map((turn) => `${formatClock(turn.ts)} ${turn.role}: ${singleLine(turn.content, 360)}`);
+  const relayLines = (args.relayTranscript ?? []).slice(-maxTranscriptTurns).map((turn) => {
+    const dir = turn.dir === "toMain" ? "voice->main" : "main->voice";
+    return `${formatClock(turn.ts)} ${dir}: ${singleLine(turn.content, 360)}`;
+  });
+  const taskLine = args.activeTask ? `active=${args.activeTask.active ? "yes" : "no"} tool_calls=${args.activeTask.toolCalls ?? 0} files_touched=${args.activeTask.filesTouched ?? 0}` : "active=unknown";
+  const sections = [
+    `## Runtime Context
+
+${buildConversationRuntimeContext(/* @__PURE__ */ new Date(), args.repoRoot)}`,
+    [
+      "## Voice/Live Session Contract",
+      "",
+      `surface=voicechat session_id=${args.sessionId} turn=${args.turnCount}`,
+      `main_agent_task=${taskLine}`,
+      "Latest user utterance remains the active request. Earlier ASR transcript turns are conversational history, not new instructions.",
+      "ASR text can be noisy. Prefer consensus-filtered final turns, resolve pronouns from recent context, and ask for clarification rather than filling gaps.",
+      "Live perception is evidence for the current reply, not a topic to narrate unless the user asks about it."
+    ].join("\n")
+  ];
+  if (voiceLines.length > 0) {
+    sections.push(`## Recent Voice Conversation
+
+${quoteConversationBlock(voiceLines.join("\n"))}`);
+  }
+  if (relayLines.length > 0) {
+    sections.push(`## Main Agent Relay Stream
+
+${quoteConversationBlock(relayLines.join("\n"))}`);
+  }
+  if (args.liveContext?.trim()) {
+    sections.push(`## Live Context Frame
+
+${args.liveContext.trim()}`);
+  }
+  return sections.join("\n\n");
+}
+function singleLine(value2, maxChars) {
+  const clean5 = value2.replace(/\s+/g, " ").trim();
+  return clean5.length > maxChars ? `${clean5.slice(0, Math.max(0, maxChars - 1))}...` : clean5;
+}
+function formatClock(ts) {
+  try {
+    return new Date(ts).toLocaleTimeString("en-US", {
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit"
+    });
+  } catch {
+    return "unknown-time";
+  }
+}
+var init_conversation_context = __esm({
+  "packages/cli/src/tui/conversation-context.ts"() {
+    "use strict";
+  }
+});
+
 // packages/cli/src/tui/telegram-format.ts
 function escapeHtml2(text2) {
   return String(text2 ?? "").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
@@ -678572,7 +678745,6 @@ import {
   unlinkSync as unlinkSync34,
   readdirSync as readdirSync55,
   statSync as statSync56,
-  statfsSync as statfsSync8,
   readFileSync as readFileSync126,
   writeFileSync as writeFileSync82,
   appendFileSync as appendFileSync18
@@ -679829,42 +680001,7 @@ function telegramMemoryTags(text2, mediaSummary) {
   return tokens.filter((token) => !/^\d+$/.test(token)).slice(0, 10);
 }
 function buildTelegramRuntimeContext(now2 = /* @__PURE__ */ new Date(), repoRoot) {
-  const date = new Intl.DateTimeFormat("en-US", {
-    weekday: "long",
-    year: "numeric",
-    month: "long",
-    day: "numeric"
-  }).format(now2);
-  const time = new Intl.DateTimeFormat("en-US", {
-    hour: "numeric",
-    minute: "2-digit",
-    second: "2-digit",
-    timeZoneName: "short"
-  }).format(now2);
-  const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone || process.env["TZ"] || "system";
-  let diskLine = "";
-  if (repoRoot) {
-    try {
-      const stats = statfsSync8(repoRoot);
-      const totalBytes = stats.blocks * stats.bsize;
-      const freeBytes = stats.bavail * stats.bsize;
-      const usedBytes = totalBytes - freeBytes;
-      const totalGB = Math.round(totalBytes / 1024 ** 3);
-      const freeGB = Math.round(freeBytes / 1024 ** 3);
-      const usedGB = Math.round(usedBytes / 1024 ** 3);
-      const usedPct = totalBytes > 0 ? Math.round(usedBytes / totalBytes * 100) : 0;
-      diskLine = `Disk: disk_available_gb=${freeGB} disk_used_gb=${usedGB} disk_total_gb=${totalGB} disk_used_pct=${usedPct} path=${repoRoot}`;
-    } catch {
-    }
-  }
-  return [
-    `Current date: ${date}`,
-    `Current time: ${time}`,
-    `Current ISO timestamp: ${now2.toISOString()}`,
-    `Timezone: ${timezone}`,
-    repoRoot ? `Working directory: ${repoRoot}` : "",
-    diskLine
-  ].filter(Boolean).join("\n");
+  return buildConversationRuntimeContext(now2, repoRoot);
 }
 function telegramSessionIdFromKey(sessionKey) {
   return `telegram-${createHash42("sha1").update(sessionKey).digest("hex").slice(0, 16)}`;
@@ -681026,6 +681163,7 @@ var TELEGRAM_TOOL_ACTION_GROUPS, TELEGRAM_TOOL_ACTION_GROUP, TELEGRAM_TOOL_MUTAT
 var init_telegram_bridge = __esm({
   "packages/cli/src/tui/telegram-bridge.ts"() {
     "use strict";
+    init_conversation_context();
     init_telegram_format();
     init_async_process();
     init_dist8();
@@ -697648,43 +697786,21 @@ function isContextSnapshotTurn(turn) {
   return turn.role === "system" && turn.content.startsWith(CONTEXT_SNAPSHOT_PREFIX);
 }
 function isPinnedSystemTurn(turn) {
-  return turn.role === "system" && (turn.content === SYSTEM_PROMPT2 || turn.content.startsWith("Available tools (emit one-line JSON:"));
+  return turn.role === "system" && (turn.content === SYSTEM_PROMPT2 || turn.content.startsWith("Available tools."));
 }
 function buildRealtimeVoiceMessages(turns, maxMessages = MAX_REALTIME_MODEL_MESSAGES) {
-  const pinned = [];
-  const dynamic = [];
-  let latestSnapshot = null;
-  for (const turn of turns) {
-    if (isPinnedSystemTurn(turn) && !pinned.some((p2) => p2.content === turn.content)) {
-      pinned.push(turn);
-    } else if (isContextSnapshotTurn(turn)) {
-      latestSnapshot = turn;
-    } else {
-      dynamic.push(turn);
-    }
-  }
-  if (latestSnapshot) {
-    let lastUserIdx = -1;
-    for (let i2 = dynamic.length - 1; i2 >= 0; i2--) {
-      if (dynamic[i2].role === "user") {
-        lastUserIdx = i2;
-        break;
-      }
-    }
-    if (lastUserIdx >= 0) dynamic.splice(lastUserIdx, 0, latestSnapshot);
-    else dynamic.push(latestSnapshot);
-  }
-  const available = Math.max(0, maxMessages - pinned.length);
-  let windowed = dynamic.slice(-available);
-  if (latestSnapshot && available > 0 && !windowed.includes(latestSnapshot)) {
-    windowed = [latestSnapshot, ...windowed.slice(-(available - 1))];
-  }
-  return [...pinned, ...windowed];
+  return buildScopedConversationMessages(turns, {
+    maxMessages,
+    isPinnedSystemTurn,
+    isContextFrameTurn: isContextSnapshotTurn,
+    placeContextFrameBeforeLastUser: true
+  });
 }
 var VAD_SILENCE_MS, MAX_SEGMENT_MS, SUMMARY_INJECTION_INTERVAL, MAX_CONTEXT_TURNS, MAX_REALTIME_MODEL_MESSAGES, CONTEXT_SNAPSHOT_PREFIX, CONTEXT_SNAPSHOT_SCOPE, MAX_VOICE_REPLY_CHARS, AGENT_ECHO_WINDOW_MS, AGENT_ECHO_SIMILARITY, SYSTEM_PROMPT2, MIN_SIGNAL_SCORE, NOISE_ONLY_RE, VoiceChatSession;
 var init_voicechat = __esm({
   "packages/cli/src/tui/voicechat.ts"() {
     "use strict";
+    init_conversation_context();
     VAD_SILENCE_MS = 3e3;
     MAX_SEGMENT_MS = 6500;
     SUMMARY_INJECTION_INTERVAL = 4;
@@ -697699,6 +697815,7 @@ var init_voicechat = __esm({
 
 Rules:
 - ALWAYS answer the user's most recent message directly. The live context snapshot is background perception — never the topic. Do not describe cameras, feeds, or surroundings unless the user's latest message asks about them.
+- Treat this as one continuous conversation thread. Resolve pronouns from recent voice turns and main-agent relay context, but let the latest user utterance override earlier transcript noise.
 - Never repeat your previous answer. If you already described the scene, don't describe it again unless explicitly asked again — respond to what the user just said.
 - Live perception: each turn you may receive a read-only "[ACTIVE CONTEXT FRAME]" system message containing what the camera currently sees (objects, people, classifications, recent visual events) and what is currently heard (sound scene, recent sounds, transcripts). Treat it as your own live sight and hearing. When the user asks what you SEE, answer from the camera fields; when the user asks what you HEAR, answer from the audio/sound fields. If the snapshot is missing or stale, say you can't see/hear clearly right now — do not invent observations.
 - Never invent environment facts (cwd, OS, specs, repo state). If you need a precise fact from the main agent, request a tool by outputting on a single line EXACTLY one JSON object: {"tool": string, "args": object} and nothing else. Then wait for the tool result before answering.
@@ -698022,13 +698139,19 @@ Rules:
               const snap = await Promise.resolve(this.toolRelay.contextSnapshot());
               if (snap && snap.trim()) {
                 this.dropTransientSystemTurns();
+                const contextFrame = buildVoiceSessionContext({
+                  sessionId: "voicechat",
+                  turnCount: this.turnCount,
+                  voiceTranscript: this.voiceTranscript,
+                  relayTranscript: this.relayTranscript,
+                  liveContext: `${CONTEXT_SNAPSHOT_SCOPE}
+
+${snap.trim()}`
+                });
                 this.context.push({
                   role: "system",
                   content: `${CONTEXT_SNAPSHOT_PREFIX}
-turn: ${this.turnCount}
-${CONTEXT_SNAPSHOT_SCOPE}
-
-${snap.trim()}`
+${contextFrame}`
                 });
                 this.trimContext();
               }
@@ -737112,6 +737235,32 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
         sharedTranscriber: null
       };
       const engine = getListenEngine();
+      const callConsensusRequired = (() => {
+        const env2 = String(process.env["OMNIUS_ASR_CONSENSUS"] ?? "").trim().toLowerCase();
+        return !(env2 === "0" || env2 === "off" || env2 === "false");
+      })();
+      const recentCallFinals = [];
+      const normalizeCallTranscript = (value2) => value2.toLowerCase().replace(/[^\p{L}\p{N}\s']/gu, " ").replace(/\s+/g, " ").trim();
+      const isLikelyCallAsrHallucination = (normalized) => /^(thanks|thank you) for watching(?: this video)?$/.test(normalized) || /^thanks for watching and/.test(normalized) || /\bdon't forget to (like|subscribe)\b/.test(normalized);
+      const shouldDropCallFinalTranscript = (text2, evt) => {
+        if (callConsensusRequired && evt.consensus !== true) {
+          return evt.consensus === false ? "consensus rejected" : "missing consensus metadata";
+        }
+        const normalized = normalizeCallTranscript(text2);
+        if (!normalized) return "empty transcript";
+        if (isLikelyCallAsrHallucination(normalized)) {
+          return "known whisper outro hallucination";
+        }
+        const now2 = Date.now();
+        while (recentCallFinals.length > 0 && now2 - recentCallFinals[0].ts > 15e3) {
+          recentCallFinals.shift();
+        }
+        if (recentCallFinals.some((entry) => entry.normalized === normalized)) {
+          return "duplicate final transcript";
+        }
+        recentCallFinals.push({ normalized, ts: now2 });
+        return null;
+      };
       voiceSession.onUserAudio = (pcmChunk, userId) => {
         if (callState.sharedTranscriber)
           callState.sharedTranscriber.write(pcmChunk);
@@ -737142,7 +737291,7 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
                 if (result && session?.isActive) {
                   const { pcm, sampleRate } = result;
                   session.sendSpeakingStateToClient(id2, true);
-                  session.sendAudioToClient(id2, pcm);
+                  session.sendAudioToClient(id2, pcm, sampleRate);
                   const durationMs = pcm.length / 2 / sampleRate * 1e3;
                   setTimeout(
                     () => session.sendSpeakingStateToClient(id2, false),
@@ -737177,17 +737326,25 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
                 (evt) => {
                   if (!evt.text?.trim() || !voiceSession?.isActive) return;
                   const text2 = evt.text.trim();
+                  if (!evt.isFinal) return;
+                  const dropReason = shouldDropCallFinalTranscript(text2, evt);
+                  if (dropReason) {
+                    writeContent(
+                      () => renderInfo(
+                        `[call/asr] dropped ${dropReason}: "${text2.slice(0, 80)}"`
+                      )
+                    );
+                    return;
+                  }
                   writeContent(
                     () => renderVoiceSessionTranscript("user", text2)
                   );
                   voiceSession?.sendTranscript("user", text2);
-                  if (evt.isFinal) {
-                    for (const [clientId, agent] of callSubAgents) {
-                      agent.handleTranscript(text2);
-                    }
-                    if (callSubAgents.size === 0) {
-                      rl.feed(text2 + "\n");
-                    }
+                  for (const [clientId, agent] of callSubAgents) {
+                    agent.handleTranscript(text2);
+                  }
+                  if (callSubAgents.size === 0) {
+                    rl.feed(text2 + "\n");
                   }
                 }
               );
@@ -737250,7 +737407,7 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
           voiceEngine.onPCMOutput = (pcm, sampleRate) => {
             if (session?.isActive) {
               session.sendSpeakingState(true);
-              session.sendAudioToClients(pcm);
+              session.sendAudioToClients(pcm, sampleRate);
               const durationMs = pcm.length / 2 / sampleRate * 1e3;
               setTimeout(() => session.sendSpeakingState(false), durationMs);
             }

package/dist/scripts/live-whisper.py

@@ -84,6 +84,76 @@ def emit_transcript(text: str, is_final: bool = False, doa=None, consensus=None)
         event["consensus"] = bool(consensus)
     emit(event)
 
+
+def host_cuda_hardware_present() -> bool:
+    """Best-effort CUDA hardware hint, including Jetson/Orin nodes."""
+    for path in (
+        "/dev/nvidiactl",
+        "/dev/nvidia0",
+        "/dev/nvhost-gpu",
+        "/proc/driver/nvidia/gpus",
+        "/sys/devices/gpu.0",
+    ):
+        if os.path.exists(path):
+            return True
+    visible = os.environ.get("NVIDIA_VISIBLE_DEVICES", "").strip().lower()
+    return bool(visible and visible not in ("none", "void", "no"))
+
+
+def select_whisper_device() -> str:
+    """Force Whisper onto CUDA whenever PyTorch can see a CUDA device.
+
+    CPU is only allowed when CUDA is genuinely unavailable to this Python
+    runtime. If CUDA is visible but unusable, fail loudly instead of silently
+    degrading into slow CPU transcription.
+    """
+    try:
+        import torch
+    except Exception as e:
+        if host_cuda_hardware_present():
+            emit_error(f"CUDA hardware appears present, but PyTorch could not be imported for CUDA Whisper ({e}); refusing CPU fallback.")
+            sys.exit(1)
+        emit_status(f"PyTorch unavailable for CUDA probe ({e}); using CPU because CUDA is not available to Whisper.")
+        return "cpu"
+
+    try:
+        cuda_count = int(torch.cuda.device_count())
+        cuda_available = bool(torch.cuda.is_available() and cuda_count > 0)
+    except Exception as e:
+        if host_cuda_hardware_present():
+            emit_error(f"CUDA hardware appears present, but PyTorch CUDA probe failed ({e}); refusing CPU fallback.")
+            sys.exit(1)
+        emit_status(f"CUDA probe failed ({e}); using CPU because CUDA is not available to Whisper.")
+        return "cpu"
+
+    if not cuda_available:
+        cuda_version = getattr(getattr(torch, "version", None), "cuda", None)
+        if host_cuda_hardware_present():
+            emit_error(f"CUDA hardware appears present, but PyTorch reports CUDA unavailable (torch.version.cuda={cuda_version}, device_count={cuda_count}); refusing CPU fallback.")
+            sys.exit(1)
+        emit_status(f"CUDA unavailable to PyTorch (torch.version.cuda={cuda_version}, device_count={cuda_count}); using CPU fallback.")
+        return "cpu"
+
+    raw_index = os.environ.get("OMNIUS_ASR_CUDA_DEVICE", "0").strip() or "0"
+    try:
+        device_index = int(raw_index)
+    except ValueError:
+        emit_error(f"Invalid OMNIUS_ASR_CUDA_DEVICE={raw_index!r}; refusing CPU fallback because CUDA is available.")
+        sys.exit(1)
+    if device_index < 0 or device_index >= cuda_count:
+        emit_error(f"OMNIUS_ASR_CUDA_DEVICE={device_index} outside available CUDA device range 0..{cuda_count - 1}; refusing CPU fallback.")
+        sys.exit(1)
+
+    try:
+        torch.cuda.set_device(device_index)
+        name = torch.cuda.get_device_name(device_index)
+    except Exception as e:
+        emit_error(f"CUDA is available but cuda:{device_index} could not be selected ({e}); refusing CPU fallback.")
+        sys.exit(1)
+
+    emit_status(f"CUDA available; forcing Whisper onto cuda:{device_index} ({name}).")
+    return f"cuda:{device_index}"
+
 # ---------------------------------------------------------------------------
 # Venv bootstrap
 # ---------------------------------------------------------------------------
@@ -344,18 +414,15 @@ def main():
 
     import whisper
 
-    emit_status(f"Loading Whisper {args.model} model...")
+    device = select_whisper_device()
+    emit_status(f"Loading Whisper {args.model} model on {device}...")
     try:
-        device = "cpu"
-        try:
-            import torch
-            if torch.cuda.is_available():
-                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}")
+        if str(device).startswith("cuda"):
+            emit_error(f"Failed to load model on {device}; refusing CPU fallback because CUDA is available: {e}")
+        else:
+            emit_error(f"Failed to load model on CPU fallback: {e}")
         sys.exit(1)
 
     # Consensus model: hallucinations (mixed-language garbage on noisy or
@@ -363,7 +430,7 @@ def main():
     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...")
+        emit_status(f"Loading consensus Whisper {consensus_name} model on {device}...")
         try:
             consensus_model = whisper.load_model(consensus_name, device=device)
         except Exception as e:
@@ -377,7 +444,7 @@ def main():
 
     emit({"type": "ready"})
 
-    fp16 = (device == "cuda")
+    fp16 = str(device).startswith("cuda")
 
     def run_transcribe(m, samples):
         return m.transcribe(

package/npm-shrinkwrap.json

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

package/package.json

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