omnius 1.0.435 → 1.0.436

package/dist/index.js

@@ -906,9 +906,9 @@ var init_model_broker = __esm({
           // VRAM total/free comes from system-metrics; broker computes its own snapshot
         ]);
         const snapshot = this.buildSnapshot();
+        await this.checkPressure(snapshot);
         this._lastSnapshot = snapshot;
         this.emit("snapshot", snapshot);
-        this.checkPressure(snapshot);
         return snapshot;
       }
       /** Best-known current snapshot. */
@@ -42867,6 +42867,8 @@ import { join as join41, basename as basename7, extname as extname4, resolve as
 import { homedir as homedir11, tmpdir as tmpdir6 } from "node:os";
 function transcriptionPythonEnv(extra = {}) {
   const env2 = { ...process.env, ...extra };
+  if (!env2["OMNIUS_ASR_DEVICE"])
+    env2["OMNIUS_ASR_DEVICE"] = "cuda";
   applyMediaCudaDeviceFilterToEnv(env2, "asr");
   return env2;
 }
@@ -43379,17 +43381,18 @@ audio_file = ${JSON.stringify(filePath)}
 model_name = ${JSON.stringify(model)}
 try:
     import whisper
-    device = os.environ.get("OMNIUS_ASR_DEVICE", "cpu").strip().lower() or "cpu"
+    device = os.environ.get("OMNIUS_ASR_DEVICE", "cuda").strip().lower() or "cuda"
+    allow_cpu = os.environ.get("OMNIUS_ASR_ALLOW_CPU", "").strip().lower() in ("1", "true", "yes", "on")
     if device == "auto":
-        device = "cpu"
-        try:
-            import torch
-            if torch.cuda.is_available():
-                device = "cuda"
-        except Exception:
-            pass
+        device = "cuda"
+    if device.startswith("cuda"):
+        import torch
+        if not torch.cuda.is_available() or torch.cuda.device_count() <= 0:
+            raise RuntimeError(f"CUDA-only ASR requested but torch cannot use CUDA (torch.version.cuda={getattr(torch.version, 'cuda', None)}, device_count={torch.cuda.device_count()}). Install a CUDA-enabled PyTorch build for this device, or set OMNIUS_ASR_ALLOW_CPU=1 only for emergency fallback.")
+    elif device == "cpu" and not allow_cpu:
+        raise RuntimeError("CPU ASR refused. Set OMNIUS_ASR_ALLOW_CPU=1 only for explicit emergency fallback.")
     m = whisper.load_model(model_name, device=device)
-    result = m.transcribe(audio_file, fp16=(device == "cuda"), condition_on_previous_text=False)
+    result = m.transcribe(audio_file, fp16=device.startswith("cuda"), condition_on_previous_text=False)
     segments = []
     for seg in result.get("segments", []) or []:
         segments.append({"start": float(seg.get("start", 0)), "end": float(seg.get("end", seg.get("start", 0))), "text": str(seg.get("text", "")).strip()})
@@ -603816,6 +603819,10 @@ function asrConsensusEnabled() {
   const consensusEnv = String(process.env["OMNIUS_ASR_CONSENSUS"] ?? "").trim().toLowerCase();
   return !(consensusEnv === "0" || consensusEnv === "off" || consensusEnv === "false");
 }
+function liveAsrUseTranscribeCli() {
+  const value2 = String(process.env["OMNIUS_ASR_USE_TRANSCRIBE_CLI"] ?? "").trim().toLowerCase();
+  return value2 === "1" || value2 === "true" || value2 === "yes" || value2 === "on";
+}
 async function ensureVenvForTranscribeCli() {
   const bin = process.platform === "win32" ? "Scripts" : "bin";
   const exe = process.platform === "win32" ? "python.exe" : "python3";
@@ -603930,6 +603937,7 @@ var init_listen = __esm({
     "use strict";
     init_typed_node_events();
     init_async_process();
+    init_dist5();
     MANAGED_TRANSCRIBE_CLI_DIR2 = join126(homedir40(), ".omnius", "runtimes", "asr", "transcribe-cli-node");
     AUDIO_EXTENSIONS = /* @__PURE__ */ new Set([
       ".mp3",
@@ -603963,6 +603971,8 @@ var init_listen = __esm({
       doa: null,
       lastTranscript: "",
       lastTranscriptAt: 0,
+      lastPartialTranscript: "",
+      lastPartialTranscriptAt: 0,
       lastStatus: "",
       updatedAt: 0
     };
@@ -603977,6 +603987,7 @@ var init_listen = __esm({
       scriptPath;
       process = null;
       _ready = false;
+      registeredBrokerName = null;
       get ready() {
         return this._ready;
       }
@@ -604051,6 +604062,7 @@ var init_listen = __esm({
                   this._ready = true;
                   clearTimeout(timeout2);
                   updateListenLiveState({ phase: "ready", lastStatus: "whisper model loaded" });
+                  this.registerBrokerModel(evt);
                   this.emit("ready");
                   resolve76();
                   break;
@@ -604097,6 +604109,7 @@ var init_listen = __esm({
             reject(err);
           });
           onChildClose(this.process, (code8) => {
+            this.unregisterBrokerModel();
             if (!this._ready) {
               clearTimeout(timeout2);
               reject(
@@ -604114,6 +604127,7 @@ var init_listen = __esm({
       }
       /** Stop the worker. */
       stop() {
+        this.unregisterBrokerModel();
         if (this.process) {
           try {
             this.process.stdin?.end();
@@ -604124,6 +604138,40 @@ var init_listen = __esm({
         }
         this._ready = false;
       }
+      registerBrokerModel(evt) {
+        const device = String(evt["device"] ?? "");
+        const cuda = evt["cuda"] === true || device.startsWith("cuda");
+        const gpuIndexMatch = device.match(/^cuda:(\d+)/);
+        const gpuIndex = gpuIndexMatch ? Number(gpuIndexMatch[1]) : null;
+        const consensus = typeof evt["consensusModel"] === "string" && String(evt["consensusModel"]).trim() ? String(evt["consensusModel"]).trim() : "";
+        const name10 = `whisper:${this.model}${consensus ? `+${consensus}` : ""}`;
+        const vramMB = Math.max(0, Math.round(Number(evt["vramUsedMB"] ?? 0)));
+        try {
+          getModelBroker().registerLoaded({
+            key: `whisper-cli:${name10}`,
+            name: name10,
+            domain: "asr",
+            host: "whisper-cli",
+            owner: "live-asr",
+            vramMB: cuda ? vramMB : 0,
+            ramMB: cuda ? 0 : vramMB,
+            priority: 88,
+            gpuIndex,
+            gpuUuid: null
+          });
+          this.registeredBrokerName = name10;
+        } catch {
+          this.registeredBrokerName = null;
+        }
+      }
+      unregisterBrokerModel() {
+        if (!this.registeredBrokerName) return;
+        try {
+          getModelBroker().unregisterLoaded("whisper-cli", this.registeredBrokerName, "live-asr stopped");
+        } catch {
+        }
+        this.registeredBrokerName = null;
+      }
     };
     ListenEngine = class extends EventEmitter6 {
       config;
@@ -604140,6 +604188,7 @@ var init_listen = __esm({
       blinkTimer = null;
       blinkState = false;
       transcribeCliAvailable = null;
+      owners = /* @__PURE__ */ new Set();
       constructor(config) {
         super();
         this.config = {
@@ -604168,6 +604217,29 @@ var init_listen = __esm({
       get pendingTranscript() {
         return this.pendingText;
       }
+      hasOwner(owner) {
+        return this.owners.has(owner);
+      }
+      ownerCount() {
+        return this.owners.size;
+      }
+      async acquire(owner) {
+        const clean5 = owner.trim() || "shared";
+        this.owners.add(clean5);
+        if (this.active) return `Live ASR already active (${[...this.owners].join(", ")}).`;
+        const result = await this.start();
+        if (!this.active) this.owners.delete(clean5);
+        return result;
+      }
+      async release(owner) {
+        const clean5 = owner.trim() || "shared";
+        this.owners.delete(clean5);
+        if (this.owners.size > 0) {
+          return `Live ASR remains active (${[...this.owners].join(", ")}).`;
+        }
+        if (!this.active) return "Live ASR is not active.";
+        return this.stop();
+      }
       setModel(model) {
         this.config.model = model;
       }
@@ -604318,19 +604390,21 @@ 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.";
         }
-        const preferWhisperFallback = asrConsensusEnabled();
+        const consensusEnabled = asrConsensusEnabled();
+        const useTranscribeCli = liveAsrUseTranscribeCli() && !consensusEnabled;
+        const preferWhisperFallback = !useTranscribeCli;
         if (preferWhisperFallback) {
           this.emit(
             "info",
-            "ASR consensus enabled — using live-whisper.py (CUDA when available)."
+            consensusEnabled ? "ASR consensus enabled — using live-whisper.py with CUDA-only Whisper guard." : "Using live-whisper.py with CUDA-only Whisper guard."
           );
           updateListenLiveState({
             backend: "openai-whisper",
-            lastStatus: "starting consensus Whisper backend..."
+            lastStatus: consensusEnabled ? "starting consensus Whisper backend..." : "starting CUDA Whisper backend..."
           });
         }
-        let tc = preferWhisperFallback ? null : await this.loadTranscribeCli();
-        if (!preferWhisperFallback && !tc) {
+        let tc = useTranscribeCli ? await this.loadTranscribeCli() : null;
+        if (useTranscribeCli && !tc) {
           if (_bgInstallPromise) {
             this.emit("info", "Waiting for transcribe-cli install...");
             await _bgInstallPromise;
@@ -604413,7 +604487,7 @@ var init_listen = __esm({
                     if (!evt.text.trim()) return;
                     this.lastTranscriptTime = Date.now();
                     this.pendingText = evt.text.trim();
-                    updateListenLiveState({ lastTranscript: this.pendingText, lastTranscriptAt: this.lastTranscriptTime });
+                    updateListenLiveState(evt.isFinal ? { lastTranscript: this.pendingText, lastTranscriptAt: this.lastTranscriptTime } : { lastPartialTranscript: this.pendingText, lastPartialTranscriptAt: this.lastTranscriptTime });
                     this.emit("transcript", this.pendingText, evt.isFinal);
                     if (this.config.mode === "auto") this.resetSilenceTimer();
                   }
@@ -604471,7 +604545,7 @@ var init_listen = __esm({
               if (!evt.text.trim()) return;
               this.lastTranscriptTime = Date.now();
               this.pendingText = evt.text.trim();
-              updateListenLiveState({ lastTranscript: this.pendingText, lastTranscriptAt: this.lastTranscriptTime });
+              updateListenLiveState(evt.isFinal ? { lastTranscript: this.pendingText, lastTranscriptAt: this.lastTranscriptTime } : { lastPartialTranscript: this.pendingText, lastPartialTranscriptAt: this.lastTranscriptTime });
               this.emit("transcript", this.pendingText, evt.isFinal, { consensus: evt.consensus, doa: evt.doa });
               if (this.config.mode === "auto") this.resetSilenceTimer();
             });
@@ -604514,6 +604588,7 @@ transcribe-cli error: ${transcribeCliError}` : "";
       async stop() {
         if (!this.active) return "Not listening.";
         this.active = false;
+        this.owners.clear();
         this.blinkState = false;
         updateListenLiveState({ phase: "idle", speechActive: false, micLevelDb: null, lastStatus: "stopped" });
         if (this.blinkTimer) {
@@ -604609,13 +604684,14 @@ transcribe-cli error: ${transcribeCliError}` : "";
        */
       async createCallTranscriber() {
         const requireConsensus = asrConsensusEnabled();
-        let tc = requireConsensus ? null : await this.loadTranscribeCli();
-        if (!requireConsensus && !tc && _bgInstallPromise) {
+        const useTranscribeCli = liveAsrUseTranscribeCli() && !requireConsensus;
+        let tc = useTranscribeCli ? await this.loadTranscribeCli() : null;
+        if (useTranscribeCli && !tc && _bgInstallPromise) {
           await _bgInstallPromise;
           this.transcribeCliAvailable = null;
           tc = await this.loadTranscribeCli();
         }
-        if (!requireConsensus && !tc) {
+        if (useTranscribeCli && !tc) {
           try {
             await ensureManagedTranscribeCliNode();
             this.transcribeCliAvailable = null;
@@ -604623,7 +604699,7 @@ transcribe-cli error: ${transcribeCliError}` : "";
           } catch {
           }
         }
-        if (!requireConsensus && tc?.TranscribeLive && await ensureVenvForTranscribeCli()) {
+        if (useTranscribeCli && tc?.TranscribeLive && await ensureVenvForTranscribeCli()) {
           try {
             const transcriber = new tc.TranscribeLive({
               model: this.config.model,
@@ -605205,6 +605281,135 @@ function formatLiveResourceBudgetLines(width = 100) {
     `└─ leases: ${truncateAnsi(leaseText, inner - 12)}`
   ];
 }
+async function refreshLiveResourceModelSnapshot(minIntervalMs = 2500) {
+  const now2 = Date.now();
+  if (now2 - lastModelSnapshotRefreshAt < minIntervalMs) return;
+  lastModelSnapshotRefreshAt = now2;
+  await getModelBroker().pollOnce();
+}
+function formatLiveMenuResourceSummary() {
+  const snap = getLiveResourceArbiter().snapshot();
+  const broker = getModelBroker().snapshot();
+  const totalGB = snap.totalMemMB / 1024;
+  const usedGB = snap.usedMemMB / 1024;
+  const vram = broker.vramMB;
+  const vramText = vram ? `GPU/UMA ${mbToGb(vram.used)}/${mbToGb(vram.total)}GB` : "GPU/UMA unknown";
+  const cuda = broker.vramPerDevice.length > 0 ? "CUDA on" : "CUDA off/unknown";
+  return `RAM ${usedGB.toFixed(1)}/${totalGB.toFixed(1)}GB · ${vramText} · ${cuda} · models ${broker.loaded.length} loaded/${broker.inflight.length} loading`;
+}
+function formatLiveModelRuntimeLines(width = 100, opts = {}) {
+  const broker = getModelBroker().snapshot();
+  const inner = Math.max(24, width - 2);
+  const loaded = broker.loaded ?? [];
+  const inflight = broker.inflight ?? [];
+  const modelsShown = Math.max(0, opts.maxModels ?? 4);
+  const cudaAvailable = broker.vramPerDevice.length > 0;
+  const gpuLine = formatGpuRuntimeLine(broker);
+  const subsystemLine = formatSubsystemMemoryLine(loaded, inner);
+  const unattributedLine = formatUnattributedMemoryLine(loaded, broker);
+  const pollAge = broker.lastPollAt > 0 ? Math.max(0, Math.round((Date.now() - broker.lastPollAt) / 1e3)) : null;
+  const lines = [
+    colorText(" model runtime", 81),
+    gpuLine,
+    subsystemLine,
+    unattributedLine,
+    `├─ state: loaded=${loaded.length} loading=${inflight.length} slots=${broker.slots.inUse}/${broker.slots.capacity} queue=${broker.slots.queueDepth}/${broker.slots.queueCapacity}${pollAge !== null ? ` poll=${pollAge}s` : ""}`
+  ];
+  if (loaded.length === 0 && inflight.length === 0) {
+    lines.push(`└─ models: ${colorText("none tracked yet", 244)}${cudaAvailable ? "" : colorText(" (CUDA state unknown until broker/JTOP poll succeeds)", 244)}`);
+    return lines;
+  }
+  const modelLines = loaded.sort((a2, b) => b.vramMB + b.ramMB - (a2.vramMB + a2.ramMB)).slice(0, modelsShown).map((model, index, shown) => {
+    const last2 = index === shown.length - 1 && inflight.length === 0 && loaded.length <= modelsShown;
+    return `${last2 ? "└" : "├"}─ ${formatLoadedModelRuntime(model, broker)}`;
+  });
+  lines.push(...modelLines.map((line) => truncateAnsi(line, inner)));
+  if (loaded.length > modelsShown) {
+    lines.push(`├─ ${colorText(`+${loaded.length - modelsShown} more loaded model(s)`, 244)}`);
+  }
+  if (inflight.length > 0) {
+    const loading = inflight.slice(0, 3).map((entry) => {
+      const age = Math.max(0, Math.round((Date.now() - entry.startedMs) / 1e3));
+      return `${entry.key} owner=${entry.owner} ${age}s`;
+    }).join("; ");
+    lines.push(`└─ loading: ${truncateAnsi(loading, inner - 12)}`);
+  }
+  return lines;
+}
+function formatLiveResourceModelReport(width = 100) {
+  return [
+    ...formatLiveResourceBudgetLines(width),
+    ...formatLiveModelRuntimeLines(width, { maxModels: 20 })
+  ].join("\n");
+}
+function formatGpuRuntimeLine(broker) {
+  const devices = broker.vramPerDevice ?? [];
+  if (devices.length === 0) {
+    return `├─ accelerator: ${colorText("CUDA off/unknown", 208)}  vram=unavailable`;
+  }
+  const parts = devices.map((device) => {
+    const label = device.uuid === "jetson-uma" ? "jetson-uma" : `gpu${device.index}`;
+    const pct = device.total > 0 ? device.used / device.total : 0;
+    return `${label} ${pressureColor(pct, 0.78)(`${mbToGb(device.used)}/${mbToGb(device.total)}GB`)}`;
+  });
+  return `├─ accelerator: ${colorText("CUDA on", 82)}  ${parts.join("  ")}`;
+}
+function formatSubsystemMemoryLine(loaded, width) {
+  const totals = /* @__PURE__ */ new Map();
+  for (const model of loaded) {
+    const key = subsystemForModel(model);
+    const current = totals.get(key) ?? { vram: 0, ram: 0, count: 0 };
+    current.vram += Math.max(0, Number(model.vramMB ?? 0));
+    current.ram += Math.max(0, Number(model.ramMB ?? 0));
+    current.count += 1;
+    totals.set(key, current);
+  }
+  if (totals.size === 0) return `├─ subsystems(tracked): ${colorText("no tracked model memory", 244)}`;
+  const preferred = ["llm", "vision", "asr", "embedding", "image", "video", "audio", "other"];
+  const parts = [...totals.entries()].sort((a2, b) => {
+    const ai = preferred.indexOf(a2[0]);
+    const bi = preferred.indexOf(b[0]);
+    return (ai === -1 ? 99 : ai) - (bi === -1 ? 99 : bi);
+  }).map(([name10, total]) => `${name10}=${mbToGb(total.vram)}Gv/${mbToGb(total.ram)}Gr`);
+  return `├─ subsystems(tracked): ${truncateAnsi(parts.join("  "), width - 25)}`;
+}
+function formatUnattributedMemoryLine(loaded, broker) {
+  const resource = getLiveResourceArbiter().snapshot();
+  const trackedRam = loaded.reduce((sum, model) => sum + Math.max(0, Number(model.ramMB ?? 0)), 0);
+  const trackedVram = loaded.reduce((sum, model) => sum + Math.max(0, Number(model.vramMB ?? 0)), 0);
+  const ramGap = Math.max(0, resource.usedMemMB - trackedRam);
+  const vramGap = broker.vramMB ? Math.max(0, broker.vramMB.used - trackedVram) : null;
+  return `├─ unattributed/system: ram=${mbToGb(ramGap)}G${vramGap !== null ? ` vram/uma=${mbToGb(vramGap)}G` : ""} ${colorText("(OS, camera ffmpeg, CV libs, CUDA overhead, untracked subprocesses)", 244)}`;
+}
+function formatLoadedModelRuntime(model, broker) {
+  const slots = broker.slots.byModel[model.name] ?? broker.slots.byModel[model.key] ?? null;
+  const active = slots && slots.inUse > 0;
+  const state = active ? colorText(`running x${slots.inUse}`, 82) : colorText("loaded idle", 244);
+  const cuda = cudaStateForModel(model, broker.vramPerDevice.length > 0);
+  const idle = Math.max(0, Math.round((Date.now() - model.lastUsedAt) / 1e3));
+  const tps = slots && slots.samples > 0 ? ` ${slots.tokensPerSec.toFixed(1)}tok/s` : "";
+  const ctx3 = model.numCtx ? ` ctx=${model.numCtx}` : "";
+  return `${subsystemForModel(model)} ${model.host}:${model.name} ${state} ${cuda} vram=${model.vramMB}MB ram=${model.ramMB}MB idle=${idle}s${tps}${ctx3}`;
+}
+function cudaStateForModel(model, cudaAvailable) {
+  if (model.gpuIndex !== null && model.gpuIndex !== void 0) return colorText(`cuda:on gpu${model.gpuIndex}`, 82);
+  if (model.vramMB > 0) return colorText(cudaAvailable ? "cuda:on" : "gpu:on", 82);
+  if (model.host === "external") return colorText("cuda:external", 244);
+  return colorText(cudaAvailable ? "cuda:off/cpu" : "cuda:off", 208);
+}
+function subsystemForModel(model) {
+  if (model.domain === "chat" || model.domain === "subagent") return "llm";
+  if (model.domain === "vision" || model.host.includes("moondream")) return "vision";
+  if (model.domain === "asr" || model.host.includes("whisper")) return "asr";
+  if (model.domain === "embedding") return "embedding";
+  if (model.domain === "image-gen") return "image";
+  if (model.domain === "video-gen") return "video";
+  if (model.domain === "tts" || model.domain === "music" || model.domain === "sound") return "audio";
+  return "other";
+}
+function mbToGb(mb) {
+  return (Math.max(0, Number(mb) || 0) / 1024).toFixed(1);
+}
 function readBudget() {
   const raw = String(process.env["OMNIUS_LIVE_RESOURCE_BUDGET"] ?? "").trim().toLowerCase();
   if (raw === "low" || raw === "conserve" || raw === "conservative" || raw === "battery") return "conserve";
@@ -605240,10 +605445,11 @@ function truncateAnsi(text2, max) {
   if (plain.length <= max) return text2;
   return `${plain.slice(0, Math.max(0, max - 3))}...`;
 }
-var LiveResourceArbiter, singleton;
+var LiveResourceArbiter, singleton, lastModelSnapshotRefreshAt;
 var init_live_resource_arbiter = __esm({
   "packages/cli/src/tui/live-resource-arbiter.ts"() {
     "use strict";
+    init_dist5();
     LiveResourceArbiter = class {
       leases = /* @__PURE__ */ new Map();
       seq = 0;
@@ -605400,6 +605606,7 @@ var init_live_resource_arbiter = __esm({
       }
     };
     singleton = null;
+    lastModelSnapshotRefreshAt = 0;
   }
 });
 
@@ -605645,6 +605852,18 @@ function truncateCell(value2, width) {
 function stripDashboardAnsi(value2) {
   return value2.replace(/\x1B\[[0-?]*[ -/]*[@-~]/g, "");
 }
+function dashboardAnsi(code8, text2) {
+  return `\x1B[${code8}m${text2}\x1B[0m`;
+}
+function dashboardDim(text2) {
+  return dashboardAnsi("38;5;244", text2);
+}
+function dashboardSoundColor(score) {
+  if (score === void 0) return "38;5;81";
+  if (score >= 0.75) return "38;5;82";
+  if (score >= 0.5) return "38;5;220";
+  return "38;5;208";
+}
 function dashboardVisibleWidth(value2) {
   return stripDashboardAnsi(value2).length;
 }
@@ -605893,13 +606112,6 @@ function readPcm16WavActivity(filePath, bins = 36) {
     return void 0;
   }
 }
-function extractAsrBackend(output) {
-  const match = String(output ?? "").match(/^Backend:\s*(.+)$/m);
-  if (!match?.[1]) return void 0;
-  const backend = match[1].trim();
-  if (/managed openai-whisper|transcribe-cli|whisper/i.test(backend)) return backend;
-  return backend.slice(0, 80);
-}
 function parseLiveAudioIntakeDecision(value2) {
   const parsed = parseJsonObjectFromText(value2);
   if (!parsed) return null;
@@ -606293,6 +606505,23 @@ function formatAudioAnalysisDashboardSummary(value2) {
   }
   return `sound: ${trimOneLine(text2.replace(/\{[\s\S]*$/, ""), 140) || trimOneLine(text2, 140)}`;
 }
+function formatAudioAnalysisDashboardSummaryColored(value2) {
+  const text2 = String(value2 ?? "").trim();
+  if (!text2) return "";
+  const parsed = parseJsonObjectFromText(text2);
+  const classifications = Array.isArray(parsed?.["classifications"]) ? parsed["classifications"] : [];
+  if (classifications.length > 0) {
+    const parts = classifications.slice(0, 4).map((entry) => {
+      const label = trimOneLine(entry["class"] ?? entry["label"] ?? entry["name"] ?? "sound", 44);
+      const score = boundedConfidence(entry["score"] ?? entry["confidence"]);
+      const coloredLabel = dashboardAnsi(dashboardSoundColor(score), label || "sound");
+      return `${coloredLabel}${score !== void 0 ? ` ${dashboardDim(score.toFixed(2))}` : ""}`;
+    });
+    return `${dashboardAnsi("38;5;45", "sounds heard")}: ${parts.join(dashboardDim("; "))}`;
+  }
+  const summary = trimOneLine(text2.replace(/\{[\s\S]*$/, ""), 140) || trimOneLine(text2, 140);
+  return `${dashboardAnsi("38;5;45", "sound")}: ${dashboardAnsi("38;5;250", summary)}`;
+}
 function formatCameraRotationDashboard(camera) {
   const orientation = camera.orientation;
   const rotation = orientation?.rotation ?? camera.rotation ?? 0;
@@ -606378,6 +606607,9 @@ function formatLiveDashboardFromSnapshot(snapshot, opts = {}) {
   for (const budgetLine of formatLiveResourceBudgetLines(width - 2)) {
     lines.push(`│${truncateAnsiCell(budgetLine, width - 2)}│`);
   }
+  for (const modelLine of formatLiveModelRuntimeLines(width - 2, { maxModels: 4 })) {
+    lines.push(`│${truncateAnsiCell(modelLine, width - 2)}│`);
+  }
   const enabledStreams = Object.entries(snapshot.config.cameraStreams ?? {}).filter(([, stream]) => stream.enabled !== false);
   const selectedResolution = snapshot.config.selectedCamera ? formatLiveCameraResolution(snapshot.config.cameraStreams?.[snapshot.config.selectedCamera]?.resolution) : "none";
   lines.push(`│${truncateCell(` systems: camera-streams=${enabledStreams.length}/${snapshot.devices.video.length} selected-res=${selectedResolution} yolo=${snapshot.config.inferEnabled ? "on" : "off"} clip=${snapshot.config.clipEnabled ? "on" : "off"} asr=${snapshot.config.asrEnabled ? "on" : "off"} sounds=${snapshot.config.audioAnalysisEnabled ? "on" : "off"}`, width - 2)}│`);
@@ -606423,13 +606655,16 @@ function formatLiveDashboardFromSnapshot(snapshot, opts = {}) {
       pushDashboardWrapped(lines, detail, width);
     }
   });
-  if (snapshot.audio) {
+  const dashboardAsr = getListenLiveState();
+  const showDashboardAudio = Boolean(snapshot.audio) || dashboardAsr.phase !== "idle";
+  if (showDashboardAudio) {
+    const audioSnapshot = snapshot.audio;
     lines.push(`├${horizontal}┤`);
     lines.push(`│${truncateCell(" audio monitor", width - 2)}│`);
-    const transcriptFailure = isAudioFailureText(snapshot.audio.transcript) ? snapshot.audio.transcript : "";
-    const transcript = transcriptFailure ? "" : snapshot.audio.transcript;
-    const audioError = sanitizeLiveAudioError([snapshot.audio.error, transcriptFailure].filter(Boolean).join(" | "));
-    const asr = getListenLiveState();
+    const transcriptFailure = audioSnapshot && isAudioFailureText(audioSnapshot.transcript) ? audioSnapshot.transcript : "";
+    const transcript = audioSnapshot && !transcriptFailure ? audioSnapshot.transcript : "";
+    const audioError = sanitizeLiveAudioError([audioSnapshot?.error, transcriptFailure].filter(Boolean).join(" | "));
+    const asr = dashboardAsr;
     const asrPhaseLabel = {
       bootstrapping: "bootstrapping deps…",
       "loading-model": "loading model…",
@@ -606440,21 +606675,26 @@ function formatLiveDashboardFromSnapshot(snapshot, opts = {}) {
     };
     const asrMicBits = asr.micLevelDb !== null ? `  mic=${asr.micLevelDb.toFixed(1)}dB${asr.speechActive ? "  ●speech" : ""}${asr.doa !== null ? `  dir=${asr.doa}°` : ""}` : "";
     const asrLine = asr.phase !== "idle" ? `│  ├─ whisper: ${[asr.backend, asr.model].filter(Boolean).join(" ") || "starting"} — ${asrPhaseLabel[asr.phase] ?? asr.phase}${asrMicBits}` : "";
-    const asrHeardAge = asr.lastTranscriptAt > 0 ? Math.max(0, Math.round((now2 - asr.lastTranscriptAt) / 1e3)) : null;
-    const asrHeardLine = asr.phase !== "idle" && asr.lastTranscript ? `│  ├─ heard${asrHeardAge !== null ? ` ${asrHeardAge}s ago` : ""}: ${trimOneLine(asr.lastTranscript, 120)}` : "";
+    const asrFinalAge = asr.lastTranscriptAt > 0 ? Math.max(0, Math.round((now2 - asr.lastTranscriptAt) / 1e3)) : null;
+    const asrPartialAge = asr.lastPartialTranscriptAt > 0 ? Math.max(0, Math.round((now2 - asr.lastPartialTranscriptAt) / 1e3)) : null;
+    const showPartial = asr.lastPartialTranscript && (!asr.lastTranscriptAt || asr.lastPartialTranscriptAt >= asr.lastTranscriptAt);
+    const asrHeardLine = asr.phase !== "idle" && (showPartial || asr.lastTranscript) ? showPartial ? `│  ├─ hearing${asrPartialAge !== null ? ` ${asrPartialAge}s ago` : ""}: ${trimOneLine(asr.lastPartialTranscript, 120)}` : `│  ├─ heard${asrFinalAge !== null ? ` ${asrFinalAge}s ago` : ""}: ${trimOneLine(asr.lastTranscript, 120)}` : "";
     const asrStatusLine = (asr.phase === "bootstrapping" || asr.phase === "loading-model" || asr.phase === "error") && asr.lastStatus ? `│  ├─ whisper status: ${trimOneLine(asr.lastStatus, 120)}` : "";
+    const coloredSoundSummary = audioSnapshot?.analysis ? formatAudioAnalysisDashboardSummaryColored(audioSnapshot.analysis) : "";
     const audioBits = [
-      `├─ input: ${snapshot.audio.input || snapshot.config.selectedAudioInput || "none"}`,
+      `├─ input: ${audioSnapshot?.input || snapshot.config.selectedAudioInput || "none"}`,
       asrLine,
       asrStatusLine,
       asrHeardLine,
-      snapshot.audio.activity ? `│  ├─ activity: ${snapshot.audio.activity.waveform}  rms=${snapshot.audio.activity.rmsDb.toFixed(1)}dB  active=${Math.round(snapshot.audio.activity.activeRatio * 100)}%` : "",
+      audioSnapshot?.activity ? `│  ├─ activity: ${audioSnapshot.activity.waveform}  rms=${audioSnapshot.activity.rmsDb.toFixed(1)}dB  active=${Math.round(audioSnapshot.activity.activeRatio * 100)}%` : "",
       audioError ? `│  ├─ error: ${trimOneLine(audioError, 140)}` : "",
-      transcript ? `│  ├─ asr${snapshot.audio.asrBackend ? ` (${snapshot.audio.asrBackend})` : ""}: ${trimOneLine(transcript, 140)}` : "",
-      snapshot.audio.intake ? `│  ├─ intake: ${snapshot.audio.intake.intendedForAgent ? "for-agent" : "ambient"}  conf=${snapshot.audio.intake.confidence.toFixed(2)}  action=${snapshot.audio.intake.action}` : "",
-      snapshot.audio.analysis ? `│  └─ ${formatAudioAnalysisDashboardSummary(snapshot.audio.analysis)}` : ""
+      transcript ? `│  ├─ asr${audioSnapshot?.asrBackend ? ` (${audioSnapshot.asrBackend})` : ""}: ${trimOneLine(transcript, 140)}` : "",
+      audioSnapshot?.intake ? `│  ├─ intake: ${audioSnapshot.intake.intendedForAgent ? "for-agent" : "ambient"}  conf=${audioSnapshot.intake.confidence.toFixed(2)}  action=${audioSnapshot.intake.action}` : ""
     ].filter(Boolean);
     for (const item of audioBits.slice(0, 9)) pushDashboardWrapped(lines, item, width);
+    if (coloredSoundSummary) {
+      lines.push(`│${truncateAnsiCell(`  └─ ${coloredSoundSummary}`, width - 2)}│`);
+    }
   }
   lines.push(`╰${horizontal}╯`);
   return lines;
@@ -606847,6 +607087,17 @@ function formatLiveSensorContextFromSnapshot(snapshot, opts = {}) {
       lines.push(`summary: ${cameraSnapshotSummary(camera)}`);
     }
   }
+  const liveAsr = getListenLiveState();
+  const liveAsrFinalAge = liveAsr.lastTranscriptAt > 0 ? now2 - liveAsr.lastTranscriptAt : Number.POSITIVE_INFINITY;
+  const liveAsrPartialAge = liveAsr.lastPartialTranscriptAt > 0 ? now2 - liveAsr.lastPartialTranscriptAt : Number.POSITIVE_INFINITY;
+  const liveAsrText = liveAsr.lastTranscript && liveAsrFinalAge < maxAgeMs ? liveAsr.lastTranscript : liveAsr.lastPartialTranscript && liveAsrPartialAge < Math.min(maxAgeMs, 3e4) ? liveAsr.lastPartialTranscript : "";
+  if (liveAsrText) {
+    const label = liveAsr.lastTranscript && liveAsrFinalAge < maxAgeMs ? "Live streaming ASR" : "Live streaming ASR partial";
+    lines.push("");
+    lines.push("## LIVE STREAMING ASR");
+    lines.push(`${label}${liveAsr.backend ? ` (${liveAsr.backend} ${liveAsr.model})` : ""}:`);
+    lines.push(cleanPreview(liveAsrText, 1200));
+  }
   if (snapshot.audio) {
     const transcriptFailure = isAudioFailureText(snapshot.audio.transcript) ? snapshot.audio.transcript : "";
     const transcript = transcriptFailure ? "" : snapshot.audio.transcript;
@@ -606881,6 +607132,7 @@ function formatLiveSensorContextFromSnapshot(snapshot, opts = {}) {
       lines.push(`intake_reason: ${snapshot.audio.intake.reason}`);
     }
     if (snapshot.audio.analysis) {
+      lines.push(`Live sound summary: ${formatAudioAnalysisDashboardSummary(snapshot.audio.analysis)}`);
       lines.push("Live sound analysis:");
       lines.push(cleanPreview(snapshot.audio.analysis, 1600));
     }
@@ -607210,6 +607462,7 @@ function formatLiveStatus(snapshot) {
     `Camera orientation: ${cfg.selectedCamera ? describeCameraOrientation(cfg.cameraOrientation?.[cfg.selectedCamera]) : "none"}`,
     `Audio input: ${cfg.selectedAudioInput || "none"}`,
     `Audio output: ${cfg.selectedAudioOutput || "none"}`,
+    `Resources: ${formatLiveMenuResourceSummary()}`,
     `Snapshot: ${liveSnapshotPath(snapshot.repoRoot)}`
   ];
   if (snapshot.video?.updatedAt) {
@@ -607265,6 +607518,10 @@ var init_live_sensors = __esm({
           config: this.config,
           devices: this.devices
         };
+        try {
+          getModelBroker().startPolling(2500);
+        } catch {
+        }
         this.ensureLoops();
       }
       repoRoot;
@@ -608486,27 +608743,20 @@ ${output}`).join("\n\n");
             audioErrors.push(`No live input signal detected from selected input ${capture.device}; keeping the explicit selection.`);
           }
           if (this.config.asrEnabled) {
-            asrLease = this.resourceArbiter.claim({
-              owner: "live-asr",
-              priority: 88,
-              ttlMs: 18e3,
-              reason: "live audio ASR capture/transcription",
-              suppress: ["vision"]
-            });
-            try {
-              const asr = await new TranscribeFileTool(this.repoRoot).execute({
-                path: recordingPath,
-                model: "tiny",
-                backend: "managed-whisper"
-              });
-              if (asr.success) {
-                transcript = cleanPreview(typeof asr.llmContent === "string" ? asr.llmContent : "", 1600);
-                asrBackend = extractAsrBackend(asr.output) ?? "whisper";
-              } else {
-                audioErrors.push(`ASR unavailable: ${asr.error || asr.output || "unknown error"}`);
-              }
-            } catch (err) {
-              audioErrors.push(`ASR unavailable: ${err instanceof Error ? err.message : String(err)}`);
+            const liveAsr = getListenLiveState();
+            const now2 = Date.now();
+            const finalAge = liveAsr.lastTranscriptAt > 0 ? now2 - liveAsr.lastTranscriptAt : Number.POSITIVE_INFINITY;
+            const partialAge = liveAsr.lastPartialTranscriptAt > 0 ? now2 - liveAsr.lastPartialTranscriptAt : Number.POSITIVE_INFINITY;
+            if (liveAsr.lastTranscript && finalAge < 45e3) {
+              transcript = cleanPreview(liveAsr.lastTranscript, 1600);
+              asrBackend = [liveAsr.backend, liveAsr.model, "streaming"].filter(Boolean).join(" ");
+            } else if (liveAsr.lastPartialTranscript && partialAge < 2e4) {
+              transcript = cleanPreview(liveAsr.lastPartialTranscript, 1600);
+              asrBackend = [liveAsr.backend, liveAsr.model, "streaming-partial"].filter(Boolean).join(" ");
+            } else if (liveAsr.phase === "idle") {
+              audioErrors.push("Streaming ASR is not running. Start /live run or /listen to enable CUDA Whisper streaming.");
+            } else if (liveAsr.lastStatus) {
+              audioErrors.push(`Streaming ASR status: ${liveAsr.lastStatus}`);
             }
           }
           if (this.config.audioAnalysisEnabled) {
@@ -608528,6 +608778,13 @@ ${output}`).join("\n\n");
             analysis = parts.filter(Boolean).join("\n");
           }
           if (transcript) {
+            asrLease = this.resourceArbiter.claim({
+              owner: "live-asr",
+              priority: 88,
+              ttlMs: 18e3,
+              reason: "live streaming ASR transcript accepted",
+              suppress: ["vision"]
+            });
             intake = await classifyLiveAudioIntake(transcript, this.intakeAgentConfig);
             keepAsrLease = true;
             asrLease?.extend(
@@ -608735,17 +608992,17 @@ ${analysis}` : ""
         this.videoTimer.unref?.();
       }
       scheduleAudioLoop(delayMs) {
-        const wantsAudio = this.config.audioEnabled && (this.config.asrEnabled || this.config.audioAnalysisEnabled);
+        const wantsAudio = this.config.audioEnabled && this.config.audioAnalysisEnabled;
         if (!wantsAudio || this.audioTimer) return;
         this.audioTimer = setTimeout(async () => {
           this.audioTimer = null;
-          const stillWantsAudio = this.config.audioEnabled && (this.config.asrEnabled || this.config.audioAnalysisEnabled);
+          const stillWantsAudio = this.config.audioEnabled && this.config.audioAnalysisEnabled;
           if (!stillWantsAudio) return;
           try {
             await this.sampleAudioNow();
           } catch {
           } finally {
-            const wantsNext = this.config.audioEnabled && (this.config.asrEnabled || this.config.audioAnalysisEnabled);
+            const wantsNext = this.config.audioEnabled && this.config.audioAnalysisEnabled;
             if (wantsNext) {
               this.scheduleAudioLoop(this.config.audioIntervalMs);
             }
@@ -608783,7 +609040,7 @@ ${analysis}` : ""
           clearTimeout(this.previewTickTimer);
           this.previewTickTimer = null;
         }
-        const wantsAudio = this.config.audioEnabled && (this.config.asrEnabled || this.config.audioAnalysisEnabled);
+        const wantsAudio = this.config.audioEnabled && this.config.audioAnalysisEnabled;
         if (wantsAudio && !this.audioTimer) {
           this.scheduleAudioLoop(0);
         } else if (!wantsAudio && this.audioTimer) {
@@ -616949,7 +617206,13 @@ function renderVoiceChatCoalescedRow(row, opts) {
     return;
   }
   if (_voiceChatCoalesce) {
-    _voiceChatCoalesce.rows.push(row);
+    const replacePrefix = opts?.replaceLastPrefix;
+    const lastIndex = _voiceChatCoalesce.rows.length - 1;
+    if (replacePrefix && lastIndex >= 0 && _voiceChatCoalesce.rows[lastIndex]?.startsWith(replacePrefix)) {
+      _voiceChatCoalesce.rows[lastIndex] = row;
+    } else {
+      _voiceChatCoalesce.rows.push(row);
+    }
     host.refreshDynamicBlocks();
     return;
   }
@@ -659689,6 +659952,19 @@ function attachLiveSinks(ctx3, manager, agentEnabled = false, speechEnabledOverr
     manager.setAgentActionSink(void 0);
   }
 }
+async function ensureLiveStreamingAsr(ctx3, manager) {
+  if (!manager.getConfig().asrEnabled) return;
+  if (!ctx3.listenStart) return;
+  ctx3.listenSetMode?.("auto");
+  const msg = await ctx3.listenStart("live");
+  if (!/already active/i.test(msg)) renderInfo(`Live ASR: ${msg}`);
+}
+async function releaseLiveStreamingAsr(ctx3) {
+  try {
+    await ctx3.listenRelease?.("live");
+  } catch {
+  }
+}
 async function startLiveVoicechat(ctx3, manager) {
   const speechEnabled = Boolean(ctx3.voiceSpeak);
   attachLiveSinks(ctx3, manager, false, speechEnabled);
@@ -659920,6 +660196,7 @@ async function handleLiveCommand(ctx3, arg) {
   if (sub2 === "stop" || sub2 === "off" || sub2 === "disable") {
     manager.stopAll();
     manager.setAgentActionSink(void 0);
+    await releaseLiveStreamingAsr(ctx3);
     if (ctx3.isVoiceChatActive?.()) {
       try {
         await ctx3.voiceChatStop?.();
@@ -659938,6 +660215,7 @@ async function handleLiveCommand(ctx3, arg) {
     }
     await ensureLiveInventory(manager);
     renderInfo(manager.startRunMode({ agent: effectiveAgent, lowLatency: true, speech: effectiveAgent && Boolean(ctx3.voiceSpeak) }));
+    await ensureLiveStreamingAsr(ctx3, manager);
     return;
   }
   if (sub2 === "chat" || sub2 === "voicechat" || sub2 === "voice") {
@@ -660037,10 +660315,13 @@ async function handleLiveCommand(ctx3, arg) {
   }
   if (sub2 === "asr") {
     const cfg = manager.getConfig();
+    const enabled2 = setBool(value2, !cfg.asrEnabled);
     manager.configure({
       audioEnabled: true,
-      asrEnabled: setBool(value2, !cfg.asrEnabled)
+      asrEnabled: enabled2
     });
+    if (enabled2) await ensureLiveStreamingAsr(ctx3, manager);
+    else await releaseLiveStreamingAsr(ctx3);
     renderInfo(formatLiveStatus(manager.getSnapshot()));
     return;
   }
@@ -660328,6 +660609,7 @@ async function handleCameraCommand(ctx3, arg) {
 async function showLiveMenu(ctx3, manager) {
   await ensureLiveInventory(manager);
   while (true) {
+    await refreshLiveResourceModelSnapshot().catch(() => void 0);
     const snapshot = manager.getSnapshot();
     const cfg = manager.getConfig();
     const devices = snapshot.devices;
@@ -660339,6 +660621,15 @@ async function showLiveMenu(ctx3, manager) {
           `  video ${liveEnabled(cfg.videoEnabled)} · infer ${liveEnabled(cfg.inferEnabled)} · clip ${liveEnabled(cfg.clipEnabled)} · audio ${liveEnabled(cfg.audioEnabled)} · asr ${liveEnabled(cfg.asrEnabled)} · sounds ${liveEnabled(cfg.audioAnalysisEnabled)}`
         )
       },
+      {
+        key: "info:resources",
+        label: selectColors.dim(`  ${formatLiveMenuResourceSummary()}`)
+      },
+      {
+        key: "resources",
+        label: "Show Resource + Model State",
+        detail: "RAM/VRAM by subsystem, CUDA per loaded model, active slots, inflight loads"
+      },
       {
         key: "run-live",
         label: "Start Live Run",
@@ -660476,6 +660767,7 @@ async function showLiveMenu(ctx3, manager) {
       case "run-live":
         attachLiveSinks(ctx3, manager, false);
         renderInfo(manager.startRunMode({ agent: false, lowLatency: true, speech: false }));
+        await ensureLiveStreamingAsr(ctx3, manager);
         continue;
       case "run-agent":
         attachLiveSinks(ctx3, manager, true);
@@ -660483,6 +660775,7 @@ async function showLiveMenu(ctx3, manager) {
           renderWarning("Live PFC agent review is unavailable in this context; starting visual/audio feedback only.");
         }
         renderInfo(manager.startRunMode({ agent: Boolean(ctx3.startBackgroundPrompt), lowLatency: true, speech: Boolean(ctx3.startBackgroundPrompt && ctx3.voiceSpeak) }));
+        await ensureLiveStreamingAsr(ctx3, manager);
         continue;
       case "run-chat":
         await startLiveVoicechat(ctx3, manager);
@@ -660501,6 +660794,8 @@ async function showLiveMenu(ctx3, manager) {
         continue;
       case "toggle-asr":
         manager.configure({ audioEnabled: true, asrEnabled: !cfg.asrEnabled });
+        if (!cfg.asrEnabled) await ensureLiveStreamingAsr(ctx3, manager);
+        else await releaseLiveStreamingAsr(ctx3);
         continue;
       case "toggle-sounds":
         manager.configure({ audioEnabled: true, audioAnalysisEnabled: !cfg.audioAnalysisEnabled });
@@ -660561,6 +660856,10 @@ Previewing microphone activity...`);
           renderWarning("Live transcript UI is unavailable in this context.");
         }
         continue;
+      case "resources":
+        await refreshLiveResourceModelSnapshot(0).catch(() => void 0);
+        renderInfo(formatLiveResourceModelReport(110));
+        continue;
       case "refresh":
         renderInfo(formatLiveInventory(await manager.refreshDevices()));
         continue;
@@ -660570,6 +660869,7 @@ Previewing microphone activity...`);
       case "stop":
         manager.stopAll();
         manager.setAgentActionSink(void 0);
+        await releaseLiveStreamingAsr(ctx3);
         if (ctx3.isVoiceChatActive?.()) {
           try {
             await ctx3.voiceChatStop?.();
@@ -665644,6 +665944,7 @@ var init_commands = __esm({
     init_generative_progress();
     init_cad_model_viewer();
     init_live_sensors();
+    init_live_resource_arbiter();
     init_command_registry();
     init_hf_token_prompt();
     init_dist5();
@@ -699583,9 +699884,15 @@ Rules:
               this._retryMicTimer = null;
               if (!this.active) return;
               try {
-                await this.listen.stop().catch(() => {
-                });
-                await this.listen.start();
+                if (typeof this.listen.release === "function" && typeof this.listen.acquire === "function") {
+                  await this.listen.release("voicechat").catch(() => {
+                  });
+                  await this.listen.acquire("voicechat");
+                } else {
+                  await this.listen.stop().catch(() => {
+                  });
+                  await this.listen.start();
+                }
                 if (this.verbose) this.onStatus("Mic auto-recovered — LISTENING");
               } catch {
               }
@@ -699595,7 +699902,11 @@ Rules:
         this.listen.on("transcript", this._onTranscript);
         this.listen.on("error", this._onError);
         try {
-          await this.listen.start();
+          if (typeof this.listen.acquire === "function") {
+            await this.listen.acquire("voicechat");
+          } else {
+            await this.listen.start();
+          }
           this.setState("LISTENING");
           if (this.verbose) this.onStatus("Mic active — LISTENING for speech...");
         } catch (err) {
@@ -699622,15 +699933,21 @@ Rules:
           this.finalizeSegment();
         }
         if (this._onTranscript) {
-          this.listen.removeAllListeners("transcript");
+          if (typeof this.listen.off === "function") this.listen.off("transcript", this._onTranscript);
+          else this.listen.removeAllListeners("transcript");
           this._onTranscript = null;
         }
         if (this._onError) {
-          this.listen.removeAllListeners("error");
+          if (typeof this.listen.off === "function") this.listen.off("error", this._onError);
+          else this.listen.removeAllListeners("error");
           this._onError = null;
         }
         try {
-          await this.listen.stop();
+          if (typeof this.listen.release === "function") {
+            await this.listen.release("voicechat");
+          } else {
+            await this.listen.stop();
+          }
         } catch {
         }
         this.releaseLiveResources();
@@ -738730,8 +739047,8 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
     // Listen mode (transcribe-cli integration + live voice session)
     async listenToggle() {
       const engine = getListenEngine();
-      if (engine.isActive) {
-        const text2 = await engine.stop();
+      if (engine.isActive && engine.hasOwner("listen")) {
+        const text2 = await engine.release("listen");
         statusBar.setRecording(false);
         if (voiceSession?.isActive) {
           const sessionMsg = await voiceSession.stop();
@@ -738774,7 +739091,7 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
       engine.on("info", (msg2) => {
         writeContent(() => renderInfo(msg2));
       });
-      const msg = await engine.start();
+      const msg = await engine.acquire("listen");
       if (voiceEngine.enabled && voiceEngine.ready) {
         try {
           voiceSession = new VoiceSession();
@@ -738803,6 +739120,39 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
       }
       return msg;
     },
+    async listenStart(owner = "live") {
+      const engine = getListenEngine();
+      const available = await engine.isAvailable();
+      if (!available) {
+        return "ASR runtime unavailable. Omnius attempted managed Whisper setup; check ~/.omnius/runtimes/asr and CUDA PyTorch.";
+      }
+      const uiEngine = engine;
+      if (!uiEngine.__omniusLiveAsrUiWired) {
+        uiEngine.__omniusLiveAsrUiWired = true;
+        engine.on("recording", (active) => {
+          statusBar.setRecording(active);
+        });
+        engine.on("level", (evt) => {
+          statusBar.setMicActivity(evt.speechActive, evt.levelDb);
+        });
+        engine.on("error", (err) => {
+          writeContent(() => renderWarning(`Live ASR error: ${err.message}`));
+        });
+        engine.on("info", (msg) => {
+          if (/CUDA|Whisper|consensus|ASR|VAD|torch/i.test(msg)) {
+            writeContent(() => renderInfo(`[asr] ${msg}`));
+          }
+        });
+      }
+      return engine.acquire(owner);
+    },
+    async listenRelease(owner = "live") {
+      const engine = getListenEngine();
+      return engine.release(owner);
+    },
+    listenIsActive() {
+      return getListenEngine().isActive;
+    },
     async listenSetModel(model) {
       const engine = getListenEngine();
       engine.setModel(model);
@@ -738815,8 +739165,8 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
     },
     async listenStop() {
       const engine = getListenEngine();
-      const text2 = await engine.stop();
-      statusBar.setRecording(false);
+      const text2 = engine.hasOwner("listen") ? await engine.release("listen") : engine.ownerCount() > 0 ? "Shared ASR is still running for /live, /voicechat, or /call." : await engine.stop();
+      if (engine.ownerCount() === 0) statusBar.setRecording(false);
       if (voiceSession?.isActive) {
         const runtime = voiceSession.runtime;
         await voiceSession.stop();
@@ -739128,19 +739478,22 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
         writeContent(() => renderInfo(voiceMsg));
       }
       const { VoiceChatSession: VoiceChatSession2 } = await Promise.resolve().then(() => (init_voicechat(), voicechat_exports));
-      const { ListenEngine: ListenEngine2 } = await Promise.resolve().then(() => (init_listen(), listen_exports));
-      const listenEng = new ListenEngine2();
-      listenEng.on("recording", (active) => {
-        statusBar.setRecording(active);
-      });
-      listenEng.on("level", (evt) => {
-        statusBar.setMicActivity(evt.speechActive, evt.levelDb);
-      });
-      listenEng.on("info", (msg) => {
-        if (/consensus rejected|loading whisper|whisper model loaded|Whisper VAD|no accepted speech text|very short utterance/i.test(msg)) {
-          writeContent(() => renderInfo(`[voicechat/asr] ${msg}`));
-        }
-      });
+      const listenEng = getListenEngine();
+      const voicechatUiEngine = listenEng;
+      if (!voicechatUiEngine.__omniusVoiceChatAsrUiWired) {
+        voicechatUiEngine.__omniusVoiceChatAsrUiWired = true;
+        listenEng.on("recording", (active) => {
+          statusBar.setRecording(active);
+        });
+        listenEng.on("level", (evt) => {
+          statusBar.setMicActivity(evt.speechActive, evt.levelDb);
+        });
+        listenEng.on("info", (msg) => {
+          if (/consensus rejected|loading whisper|whisper model loaded|Whisper VAD|no accepted speech text|very short utterance/i.test(msg)) {
+            writeContent(() => renderInfo(`[voicechat/asr] ${msg}`));
+          }
+        });
+      }
       const summaryRunner = {
         injectUserMessage(content) {
           if (activeTask?.runner) {
@@ -739148,6 +739501,7 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
           }
         }
       };
+      const voicechatPartialPrefix = `\x1B[38;5;244m[hearing]\x1B[0m`;
       _voiceChatSession2 = new VoiceChatSession2({
         voice: voiceEngine,
         listen: listenEng,
@@ -739305,11 +739659,20 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
         },
         onUserSpeech(text2) {
           writeContent(
-            () => renderVoiceChatCoalescedRow(`\x1B[38;5;45m[you]\x1B[0m ${text2}`)
+            () => renderVoiceChatCoalescedRow(`\x1B[38;5;45m[you]\x1B[0m ${text2}`, {
+              replaceLastPrefix: voicechatPartialPrefix
+            })
           );
         },
-        // Suppressed to keep main loop quiet
-        onPartialTranscript(_text) {
+        onPartialTranscript(text2) {
+          const cleaned = text2.trim();
+          if (!cleaned) return;
+          writeContent(
+            () => renderVoiceChatCoalescedRow(
+              `${voicechatPartialPrefix} ${truncateByLines(cleaned, 2, 240)}`,
+              { replaceLastPrefix: voicechatPartialPrefix }
+            )
+          );
         },
         onAgentSpeech(text2) {
           writeContent(
@@ -739322,6 +739685,15 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
         onStateChange(_state4) {
         }
       });
+      _voiceChatSession2.on("consensusFiltered", (evt) => {
+        const text2 = String(evt?.text ?? "").trim();
+        writeContent(
+          () => renderVoiceChatCoalescedRow(
+            `\x1B[38;5;244m[filtered]\x1B[0m no ASR consensus${text2 ? `: ${truncateByLines(text2, 1, 180)}` : ""}`,
+            { replaceLastPrefix: voicechatPartialPrefix }
+          )
+        );
+      });
       await _voiceChatSession2.start();
     },
     async voiceChatStop() {

package/dist/scripts/live-whisper.py

@@ -85,6 +85,33 @@ def emit_transcript(text: str, is_final: bool = False, doa=None, consensus=None)
     emit(event)
 
 
+def emit_consensus_rejected(primary: str, secondary: str, reason: str):
+    emit({
+        "type": "consensus_rejected",
+        "primary": primary[:200],
+        "secondary": (secondary or "")[:200],
+        "reason": reason,
+    })
+
+
+def cuda_memory_reserved_mb(device: str) -> int:
+    if not str(device).startswith("cuda"):
+        return 0
+    try:
+        import torch
+        raw = str(device).split(":", 1)[1] if ":" in str(device) else ""
+        index = int(raw) if raw.strip().isdigit() else torch.cuda.current_device()
+        try:
+            torch.cuda.synchronize(index)
+        except Exception:
+            pass
+        reserved = int(torch.cuda.memory_reserved(index))
+        allocated = int(torch.cuda.memory_allocated(index))
+        return max(0, round(max(reserved, allocated) / (1024 * 1024)))
+    except Exception:
+        return 0
+
+
 def host_cuda_hardware_present() -> bool:
     """Best-effort CUDA hardware hint, including Jetson/Orin nodes."""
     for path in (
@@ -100,6 +127,32 @@ def host_cuda_hardware_present() -> bool:
     return bool(visible and visible not in ("none", "void", "no"))
 
 
+def asr_cpu_allowed() -> bool:
+    raw = os.environ.get("OMNIUS_ASR_ALLOW_CPU", "").strip().lower()
+    return raw in ("1", "true", "yes", "on")
+
+
+def jetson_host_hint() -> str:
+    try:
+        model = Path("/proc/device-tree/model").read_text(errors="ignore").replace("\x00", " ").strip()
+    except Exception:
+        model = ""
+    if model and any(token in model.lower() for token in ("jetson", "orin", "tegra")):
+        return (
+            f" Detected {model}. Install a JetPack/L4T-compatible CUDA PyTorch wheel in the Omnius ASR venv; "
+            "the generic pip torch wheel is often CPU-only or CUDA-incompatible on Jetson."
+        )
+    return ""
+
+
+def cuda_required_error(reason: str):
+    emit_error(
+        f"CUDA-only ASR is enabled and Whisper cannot use CUDA: {reason}."
+        f"{jetson_host_hint()} Set OMNIUS_ASR_ALLOW_CPU=1 only for explicit emergency CPU fallback."
+    )
+    sys.exit(1)
+
+
 def select_whisper_device() -> str:
     """Force Whisper onto CUDA whenever PyTorch can see a CUDA device.
 
@@ -110,9 +163,8 @@ def select_whisper_device() -> str:
     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)
+        if host_cuda_hardware_present() or not asr_cpu_allowed():
+            cuda_required_error(f"PyTorch could not be imported ({e})")
         emit_status(f"PyTorch unavailable for CUDA probe ({e}); using CPU because CUDA is not available to Whisper.")
         return "cpu"
 
@@ -120,17 +172,15 @@ def select_whisper_device() -> str:
         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)
+        if host_cuda_hardware_present() or not asr_cpu_allowed():
+            cuda_required_error(f"PyTorch CUDA probe failed ({e})")
         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)
+        if host_cuda_hardware_present() or not asr_cpu_allowed():
+            cuda_required_error(f"PyTorch reports CUDA unavailable (torch.version.cuda={cuda_version}, device_count={cuda_count})")
         emit_status(f"CUDA unavailable to PyTorch (torch.version.cuda={cuda_version}, device_count={cuda_count}); using CPU fallback.")
         return "cpu"
 
@@ -151,7 +201,7 @@ def select_whisper_device() -> str:
         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}).")
+    emit_status(f"CUDA available; forcing Whisper onto cuda:{device_index} ({name}); torch={getattr(torch, '__version__', 'unknown')} cuda={getattr(getattr(torch, 'version', None), 'cuda', None)}.")
     return f"cuda:{device_index}"
 
 # ---------------------------------------------------------------------------
@@ -442,9 +492,15 @@ def main():
     if tuning is not None:
         emit_status("ReSpeaker DSP active: hardware VAD, echo cancellation, DOA.")
 
-    emit({"type": "ready"})
-
     fp16 = str(device).startswith("cuda")
+    emit({
+        "type": "ready",
+        "model": args.model,
+        "device": str(device),
+        "cuda": bool(fp16),
+        "consensusModel": consensus_name if consensus_model is not None else None,
+        "vramUsedMB": cuda_memory_reserved_mb(str(device)),
+    })
 
     def run_transcribe(m, samples):
         return m.transcribe(
@@ -525,47 +581,46 @@ def main():
             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
+            result = run_transcribe(model, samples)
 
             text = _segment_filtered_text(result)
             if not text:
                 emit_status("Whisper final produced no accepted speech 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
-            # consensus=True only when BOTH models ran and converged. When the
-            # second model is off/unavailable, omit consensus metadata entirely
-            # so legacy single-model consumers do not interpret consensus=false
-            # as an explicit dual-ASR rejection.
-            emit_transcript(
-                text,
-                is_final=True,
-                doa=tuning.doa() if tuning else None,
-                consensus=True if consensus_model is not None else None,
-            )
+            doa = tuning.doa() if tuning else None
+            if consensus_model is None:
+                last_final_text = text
+                emit_transcript(text, is_final=True, doa=doa, consensus=None)
+                return
+
+            # Fast UX path: surface the primary model's finalized text
+            # immediately as a non-final transcript. The secondary model then
+            # validates whether it is safe to accept as a final utterance.
+            emit_transcript(text, is_final=False, doa=doa, consensus=False)
+
+            def validate_consensus(primary_text, primary_result, audio_samples, primary_doa):
+                nonlocal last_final_text
+                try:
+                    secondary = run_transcribe(consensus_model, audio_samples)
+                    secondary_text = _segment_filtered_text(secondary)
+                    lang_a = str(primary_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(primary_text, secondary_text, args.consensus_threshold):
+                        emit_consensus_rejected(primary_text, secondary_text, "language_mismatch" if lang_disagree else "low_similarity")
+                        return
+                    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}")
+
+            threading.Thread(
+                target=validate_consensus,
+                args=(text, result, samples.copy(), doa),
+                daemon=True,
+            ).start()
         except Exception as e:
             emit_error(f"Transcription error: {e}")
 

package/dist/scripts/transcribe-file.py

@@ -1,20 +1,16 @@
 #!/usr/bin/env python3
 """
-Transcribe an audio file using openai-whisper (CPU-only).
+Transcribe an audio file using openai-whisper (CUDA-only by default).
 
 stdin:  JSON {"path": "...", "model": "tiny|base|small|medium|large-v3"}
 stdout: JSON {"text": "...", "duration": null, "segments": []}
         or   {"error": "<kind>", "message": "..."}
 
-Force-loads on CPU because the venv's torch may not match the local GPU
-(e.g. a GT 1030 with sm_61 against a sm_75+ torch build) — those mismatches
-print noisy CUDA warnings and then crash. CPU is slower but always works.
+ASR is GPU-first: CPU fallback is refused unless OMNIUS_ASR_ALLOW_CPU=1.
 """
 import sys, os, json, warnings
 
-# Quiet CUDA warnings from torch even though we won't use the GPU.
 warnings.filterwarnings("ignore")
-os.environ.setdefault("CUDA_VISIBLE_DEVICES", "")  # hide all GPUs
 os.environ.setdefault("PYTHONWARNINGS", "ignore")
 
 try:
@@ -39,8 +35,22 @@ def main() -> None:
 
     model_name = data.get("model") or "tiny"
     try:
-        model = whisper.load_model(model_name, device="cpu")
-        result = model.transcribe(path, fp16=False)
+        device = os.environ.get("OMNIUS_ASR_DEVICE", "cuda").strip().lower() or "cuda"
+        allow_cpu = os.environ.get("OMNIUS_ASR_ALLOW_CPU", "").strip().lower() in ("1", "true", "yes", "on")
+        if device == "auto":
+            device = "cuda"
+        if device.startswith("cuda"):
+            import torch
+            if not torch.cuda.is_available() or torch.cuda.device_count() <= 0:
+                raise RuntimeError(
+                    f"CUDA-only ASR requested but torch cannot use CUDA "
+                    f"(torch.version.cuda={getattr(torch.version, 'cuda', None)}, device_count={torch.cuda.device_count()}). "
+                    "Install a CUDA-enabled PyTorch build for this device, or set OMNIUS_ASR_ALLOW_CPU=1 only for emergency fallback."
+                )
+        elif device == "cpu" and not allow_cpu:
+            raise RuntimeError("CPU ASR refused. Set OMNIUS_ASR_ALLOW_CPU=1 only for explicit emergency fallback.")
+        model = whisper.load_model(model_name, device=device)
+        result = model.transcribe(path, fp16=device.startswith("cuda"), condition_on_previous_text=False)
     except Exception as e:
         print(json.dumps({"error": "whisper_failed", "message": str(e)}))
         return

package/npm-shrinkwrap.json

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

package/package.json

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