omnius 1.0.408 → 1.0.410

package/dist/index.js

@@ -41519,7 +41519,7 @@ function formatTime(seconds) {
   const s2 = Math.floor(seconds % 60);
   return `${String(m2).padStart(2, "0")}:${String(s2).padStart(2, "0")}`;
 }
-var AUDIO_EXTS, VIDEO_EXTS, MAX_TRANSCRIBE_URL_BYTES, _tcModule, _tcChecked, TranscribeFileTool, YT_DLP_VENV, TranscribeUrlTool, YouTubeDownloadTool;
+var AUDIO_EXTS, VIDEO_EXTS, MAX_TRANSCRIBE_URL_BYTES, MANAGED_ASR_VENV, _tcModule, _tcChecked, _managedAsrReady, TranscribeFileTool, YT_DLP_VENV, TranscribeUrlTool, YouTubeDownloadTool;
 var init_transcribe_tool = __esm({
   "packages/execution/dist/tools/transcribe-tool.js"() {
     "use strict";
@@ -41550,8 +41550,10 @@ var init_transcribe_tool = __esm({
       ".ts"
     ]);
     MAX_TRANSCRIBE_URL_BYTES = 100 * 1024 * 1024;
+    MANAGED_ASR_VENV = join40(homedir11(), ".omnius", "runtimes", "asr", ".venv-whisper");
     _tcModule = null;
     _tcChecked = false;
+    _managedAsrReady = false;
     TranscribeFileTool = class {
       name = "transcribe_file";
       description = "Transcribe a local audio or video file to text using Whisper (faster-whisper). Supports MP3, WAV, FLAC, AAC, M4A, OGG, MP4, MKV, AVI, MOV, WebM. Returns the full transcription text with optional speaker diarization. Transcription is 100% local — no API keys needed.";
@@ -41625,102 +41627,131 @@ var init_transcribe_tool = __esm({
         }
         if (effectiveModel !== askedModel)
           model = effectiveModel;
+        const failures = [];
         const tc = await loadTranscribeCli();
-        if (!tc) {
-          return this.execViaCli(filePath, model, diarize, start2);
-        }
+        if (tc) {
+          try {
+            const result = await withProcessEnv(transcriptionPythonEnv(), () => tc.transcribe(filePath, {
+              model,
+              format: "json",
+              diarize,
+              wordTimestamps: true
+            }));
+            return this.formatTranscriptionResult(filePath, model, result, start2, "transcribe-cli");
+          } catch (err) {
+            failures.push(`transcribe-cli module: ${err instanceof Error ? err.message : String(err)}`);
+          }
+        }
+        const cli = await this.execViaCli(filePath, model, diarize, start2);
+        if (cli.success)
+          return cli;
+        if (cli.error)
+          failures.push(cli.error);
+        const managed = await this.execViaManagedWhisper(filePath, model, start2);
+        if (managed.success)
+          return managed;
+        if (managed.error)
+          failures.push(managed.error);
+        return {
+          success: false,
+          output: "",
+          error: `Transcription failed after all ASR backends. ${failures.join(" | ").slice(0, 1200)}`,
+          durationMs: performance.now() - start2
+        };
+      }
+      formatTranscriptionResult(filePath, model, result, start2, backend) {
+        const segments = Array.isArray(result.segments) ? result.segments : [];
+        const text2 = String(result.text ?? result.fullText ?? "").trim();
+        const speakers = Array.isArray(result.speakers) ? result.speakers : [];
+        const wordCount2 = Number(result.wordCount ?? (text2 ? text2.split(/\s+/).filter(Boolean).length : 0));
+        const transcriptDir = join40(this.workingDir, ".omnius", "transcripts");
+        mkdirSync22(transcriptDir, { recursive: true });
+        const fileBase = basename7(filePath).replace(/\.[^.]+$/, "");
+        const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
+        const txtFile = join40(transcriptDir, `${fileBase}-${timestamp}.txt`);
+        const jsonFile = join40(transcriptDir, `${fileBase}-${timestamp}.json`);
+        writeFileSync21(txtFile, text2, "utf-8");
+        const structured = {
+          source: filePath,
+          model,
+          backend,
+          language: result.language,
+          duration: result.duration,
+          wordCount: wordCount2,
+          speakers,
+          transcribedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          segments: segments.map((seg) => ({
+            start: Number(seg.start ?? 0),
+            end: Number(seg.end ?? seg.start ?? 0),
+            text: String(seg.text ?? ""),
+            speaker: seg.speaker || void 0
+          })),
+          fullText: text2
+        };
+        writeFileSync21(jsonFile, JSON.stringify(structured, null, 2), "utf-8");
         try {
-          const result = await withProcessEnv(transcriptionPythonEnv(), () => tc.transcribe(filePath, {
-            model,
-            format: "json",
-            diarize,
-            wordTimestamps: true
-            // Always get timestamps for structured output
-          }));
-          const transcriptDir = join40(this.workingDir, ".omnius", "transcripts");
-          mkdirSync22(transcriptDir, { recursive: true });
-          const fileBase = basename7(filePath).replace(/\.[^.]+$/, "");
-          const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
-          const txtFile = join40(transcriptDir, `${fileBase}-${timestamp}.txt`);
-          writeFileSync21(txtFile, result.text, "utf-8");
-          const jsonFile = join40(transcriptDir, `${fileBase}-${timestamp}.json`);
-          const structured = {
-            source: filePath,
-            model,
-            language: result.language,
-            duration: result.duration,
-            wordCount: result.wordCount,
-            speakers: result.speakers,
-            transcribedAt: (/* @__PURE__ */ new Date()).toISOString(),
-            segments: result.segments.map((seg) => ({
-              start: seg.start,
-              end: seg.end,
-              text: seg.text,
-              speaker: seg.speaker || void 0
-            })),
-            fullText: result.text
-          };
-          writeFileSync21(jsonFile, JSON.stringify(structured, null, 2), "utf-8");
+          const memDir = join40(this.workingDir, ".omnius", "memory");
+          mkdirSync22(memDir, { recursive: true });
+          const memFile = join40(memDir, "transcripts.json");
+          let memEntries = [];
           try {
-            const memDir = join40(this.workingDir, ".omnius", "memory");
-            mkdirSync22(memDir, { recursive: true });
-            const memFile = join40(memDir, "transcripts.json");
-            let memEntries = [];
-            try {
-              memEntries = JSON.parse(readFileSync30(memFile, "utf-8"));
-            } catch {
-            }
-            memEntries.push({
-              source: basename7(filePath),
-              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-              duration: result.duration,
-              wordCount: result.wordCount,
-              language: result.language,
-              summary: result.text.slice(0, 200),
-              jsonPath: jsonFile,
-              txtPath: txtFile
-            });
-            if (memEntries.length > 50)
-              memEntries = memEntries.slice(-50);
-            writeFileSync21(memFile, JSON.stringify(memEntries, null, 2), "utf-8");
+            memEntries = JSON.parse(readFileSync30(memFile, "utf-8"));
           } catch {
           }
-          const lines = [
-            `Transcription of: ${basename7(filePath)}`,
-            `Model: ${model} | Language: ${result.language} | Duration: ${result.duration ? `${result.duration.toFixed(1)}s` : "unknown"}`,
-            `Words: ${result.wordCount} | Segments: ${result.segments.length}`,
-            `Saved: ${txtFile} (text) + ${jsonFile} (structured with timestamps)`,
-            ""
-          ];
-          if (result.speakers.length > 1) {
-            lines.push(`Speakers: ${result.speakers.join(", ")}`);
-            lines.push("");
-          }
-          if (result.segments.length > 0) {
-            for (const seg of result.segments) {
-              const ts = `[${formatTime(seg.start)} → ${formatTime(seg.end)}]`;
-              const speaker = seg.speaker ? `${seg.speaker}: ` : "";
-              lines.push(`${ts} ${speaker}${seg.text}`);
-            }
-          } else {
-            lines.push(result.text);
+          memEntries.push({
+            source: basename7(filePath),
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            duration: result.duration,
+            wordCount: wordCount2,
+            language: result.language,
+            backend,
+            summary: text2.slice(0, 200),
+            jsonPath: jsonFile,
+            txtPath: txtFile
+          });
+          if (memEntries.length > 50)
+            memEntries = memEntries.slice(-50);
+          writeFileSync21(memFile, JSON.stringify(memEntries, null, 2), "utf-8");
+        } catch {
+        }
+        const lines = [
+          `Transcription of: ${basename7(filePath)}`,
+          `Backend: ${backend}`,
+          `Model: ${model} | Language: ${result.language ?? "unknown"} | Duration: ${result.duration ? `${Number(result.duration).toFixed(1)}s` : "unknown"}`,
+          `Words: ${wordCount2} | Segments: ${segments.length}`,
+          `Saved: ${txtFile} (text) + ${jsonFile} (structured with timestamps)`,
+          ""
+        ];
+        if (speakers.length > 1) {
+          lines.push(`Speakers: ${speakers.join(", ")}`);
+          lines.push("");
+        }
+        if (segments.length > 0) {
+          for (const seg of segments) {
+            const ts = `[${formatTime(Number(seg.start ?? 0))} → ${formatTime(Number(seg.end ?? seg.start ?? 0))}]`;
+            const speaker = seg.speaker ? `${seg.speaker}: ` : "";
+            lines.push(`${ts} ${speaker}${String(seg.text ?? "").trim()}`);
           }
-          return {
-            success: true,
-            output: lines.join("\n"),
-            durationMs: performance.now() - start2
-          };
-        } catch (err) {
+        } else {
+          lines.push(text2 || "[silent — no speech detected]");
+        }
+        return {
+          success: true,
+          output: lines.join("\n"),
+          llmContent: text2,
+          durationMs: performance.now() - start2
+        };
+      }
+      /** Fallback: invoke transcribe-cli as a subprocess. */
+      async execViaCli(filePath, model, diarize, start2) {
+        if (!await commandExists("transcribe-cli", 1500)) {
           return {
             success: false,
             output: "",
-            error: `Transcription failed: ${err instanceof Error ? err.message : String(err)}`,
+            error: "transcribe-cli command unavailable",
             durationMs: performance.now() - start2
           };
         }
-      }
-      /** Fallback: invoke transcribe-cli as a subprocess. */
-      async execViaCli(filePath, model, diarize, start2) {
         try {
           const args = [filePath, "-m", model, "-f", "txt"];
           if (diarize)
@@ -41734,6 +41765,7 @@ var init_transcribe_tool = __esm({
           return {
             success: true,
             output: output.trim() || "(empty transcription)",
+            llmContent: output.trim() || "",
             durationMs: performance.now() - start2
           };
         } catch (err) {
@@ -41747,6 +41779,112 @@ var init_transcribe_tool = __esm({
           };
         }
       }
+      async ensureManagedWhisperRuntime() {
+        const python = venvPython(MANAGED_ASR_VENV);
+        if (!existsSync38(python)) {
+          mkdirSync22(join40(homedir11(), ".omnius", "runtimes", "asr"), { recursive: true });
+          await execFileText("python3", ["-m", "venv", MANAGED_ASR_VENV], {
+            timeout: 6e4,
+            env: transcriptionPythonEnv()
+          });
+        }
+        if (_managedAsrReady)
+          return python;
+        try {
+          await execFileText(python, ["-c", "import whisper, numpy"], {
+            timeout: 1e4,
+            env: transcriptionPythonEnv()
+          });
+          _managedAsrReady = true;
+          return python;
+        } catch {
+          await execFileText(python, [
+            "-m",
+            "pip",
+            "install",
+            "-U",
+            "pip",
+            "wheel",
+            "setuptools",
+            "numpy",
+            "openai-whisper"
+          ], {
+            timeout: 9e5,
+            env: transcriptionPythonEnv()
+          });
+          _managedAsrReady = true;
+          return python;
+        }
+      }
+      async execViaManagedWhisper(filePath, model, start2) {
+        const scriptPath2 = join40(this.workingDir, ".omnius", "tmp", `managed-whisper-${Date.now()}.py`);
+        mkdirSync22(join40(this.workingDir, ".omnius", "tmp"), { recursive: true });
+        const script = `
+import json, os, warnings
+warnings.filterwarnings("ignore")
+os.environ.setdefault("TF_CPP_MIN_LOG_LEVEL", "3")
+audio_file = ${JSON.stringify(filePath)}
+model_name = ${JSON.stringify(model)}
+try:
+    import whisper
+    device = "cpu"
+    try:
+        import torch
+        if torch.cuda.is_available():
+            device = "cuda"
+    except Exception:
+        pass
+    m = whisper.load_model(model_name, device=device)
+    result = m.transcribe(audio_file, fp16=(device == "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()})
+    text = str(result.get("text", "")).strip()
+    print(json.dumps({
+        "ok": True,
+        "text": text,
+        "language": result.get("language"),
+        "duration": segments[-1]["end"] if segments else None,
+        "wordCount": len([w for w in text.split() if w]),
+        "speakers": [],
+        "segments": segments,
+    }))
+except Exception as exc:
+    print(json.dumps({"ok": False, "error": str(exc)}))
+`;
+        try {
+          writeFileSync21(scriptPath2, script, "utf-8");
+          const python = await this.ensureManagedWhisperRuntime();
+          const raw = await execFileText(python, [scriptPath2], {
+            timeout: 6e5,
+            cwd: this.workingDir,
+            env: transcriptionPythonEnv({ PYTHONUNBUFFERED: "1" }),
+            maxBuffer: 16 * 1024 * 1024
+          });
+          const parsed = JSON.parse(raw.trim().split("\n").reverse().find((line) => line.trim().startsWith("{")) ?? "{}");
+          if (!parsed.ok) {
+            return {
+              success: false,
+              output: "",
+              error: `managed openai-whisper failed: ${parsed.error || raw.slice(-500)}`,
+              durationMs: performance.now() - start2
+            };
+          }
+          return this.formatTranscriptionResult(filePath, model, parsed, start2, "managed openai-whisper");
+        } catch (err) {
+          return {
+            success: false,
+            output: "",
+            error: `managed openai-whisper failed: ${err instanceof Error ? err.message : String(err)}`,
+            durationMs: performance.now() - start2
+          };
+        } finally {
+          try {
+            unlinkSync5(scriptPath2);
+          } catch {
+          }
+        }
+      }
     };
     YT_DLP_VENV = join40(homedir11(), ".omnius", "runtimes", "media-tools", ".venv-ytdlp");
     TranscribeUrlTool = class {
@@ -547804,17 +547942,23 @@ except Exception as e:
         const audioFile = await this.ensureAudioFile(args);
         if (!audioFile)
           return { success: false, output: "", error: "No audio available.", durationMs: performance.now() - start2 };
-        await this.ensureVenv(["torch", "torchaudio", "numpy", "soundfile"]);
+        await this.ensureVenv(["torch", "numpy", "soundfile", "resampy"]);
         const audioLiteral = JSON.stringify(audioFile);
         const script = `
 import sys, json, numpy as np
 try:
-    import torch, torchaudio, soundfile as sf
+    import torch, soundfile as sf, resampy
 
     model, utils = torch.hub.load(repo_or_dir='snakers4/silero-vad', model='silero_vad', force_reload=False, trust_repo=True)
-    (get_speech_timestamps, _, read_audio, *_) = utils
+    (get_speech_timestamps, *_) = utils
 
-    wav = read_audio(${audioLiteral}, sampling_rate=16000)
+    audio, sr = sf.read(${audioLiteral})
+    if len(getattr(audio, "shape", [])) > 1:
+        audio = audio.mean(axis=1)
+    if sr != 16000:
+        audio = resampy.resample(audio, sr, 16000)
+    audio = audio.astype(np.float32)
+    wav = torch.from_numpy(audio)
     speech_timestamps = get_speech_timestamps(wav, model, sampling_rate=16000, threshold=0.5)
 
     total_samples = len(wav)
@@ -547825,6 +547969,7 @@ try:
 
     print(json.dumps({
         "success": True,
+        "backend": "silero-vad",
         "voice_detected": len(speech_timestamps) > 0,
         "speech_percentage": round(speech_pct, 1),
         "speech_segments": len(speech_timestamps),
@@ -547832,7 +547977,57 @@ try:
         "segments": segments[:10]
     }))
 except Exception as e:
-    print(json.dumps({"success": False, "error": str(e)}))
+    try:
+        import soundfile as sf
+        import resampy
+        audio, sr = sf.read(${audioLiteral})
+        if len(getattr(audio, "shape", [])) > 1:
+            audio = audio.mean(axis=1)
+        if sr != 16000:
+            audio = resampy.resample(audio, sr, 16000)
+        audio = audio.astype(np.float32)
+        frame = max(1, int(0.03 * 16000))
+        hop = max(1, int(0.01 * 16000))
+        rms = []
+        for i in range(0, max(1, len(audio) - frame + 1), hop):
+            chunk = audio[i:i+frame]
+            if len(chunk) == 0:
+                continue
+            rms.append(float(np.sqrt(np.mean(chunk * chunk))))
+        arr = np.array(rms, dtype=np.float32)
+        if len(arr) == 0:
+            active = np.array([], dtype=bool)
+        else:
+            floor = float(np.percentile(arr, 35))
+            peak = float(np.max(arr))
+            threshold = max(0.008, floor * 2.5, peak * 0.12)
+            active = arr > threshold
+        segments = []
+        start_idx = None
+        for idx, flag in enumerate(active.tolist()):
+            if flag and start_idx is None:
+                start_idx = idx
+            if (not flag or idx == len(active) - 1) and start_idx is not None:
+                end_idx = idx if not flag else idx + 1
+                start_s = start_idx * hop / 16000.0
+                end_s = min(len(audio) / 16000.0, (end_idx * hop + frame) / 16000.0)
+                if end_s - start_s >= 0.12:
+                    segments.append({"start_s": start_s, "end_s": end_s, "duration_s": end_s - start_s})
+                start_idx = None
+        speech_duration = sum(seg["duration_s"] for seg in segments)
+        total_duration = len(audio) / 16000.0 if len(audio) else 0
+        print(json.dumps({
+            "success": True,
+            "backend": "energy-vad-fallback",
+            "warning": "silero unavailable: " + str(e),
+            "voice_detected": len(segments) > 0,
+            "speech_percentage": round((speech_duration / total_duration * 100) if total_duration else 0, 1),
+            "speech_segments": len(segments),
+            "total_duration_s": round(total_duration, 2),
+            "segments": segments[:10]
+        }))
+    except Exception as fallback:
+        print(json.dumps({"success": False, "error": str(e) + "; fallback failed: " + str(fallback)}))
 `;
         return await this.runPythonScript(script, start2, "Voice activity detection");
       }
@@ -555516,6 +555711,9 @@ function summarizeObjects(objects) {
   }
   return [...counts.entries()].sort((a2, b) => b[1].count - a2[1].count).slice(0, 12).map(([label, value2]) => `${label} x${value2.count} mean_conf=${(value2.confidence / Math.max(1, value2.count)).toFixed(2)}`);
 }
+function isDiagnosticAudioEvidence(text2) {
+  return /^(?:ASR|VAD|Audio comprehension)\s+(?:failed|unavailable|completed)|No module named ['"]?transcribe_cli|torchcodec|torchaudio version|no speech detected|empty transcription/i.test(text2.trim());
+}
 function observationsFromResult(result, extraText) {
   const observations = [];
   for (const obj of result.objects) {
@@ -555541,6 +555739,8 @@ function observationsFromResult(result, extraText) {
     });
   }
   for (const text2 of extraText) {
+    if (isDiagnosticAudioEvidence(text2))
+      continue;
     observations.push({
       type: "transcript",
       confidence: 0.75,
@@ -555958,7 +556158,12 @@ var init_live_media_loop = __esm({
             try {
               const transcribe = new TranscribeFileTool(this.workingDir);
               const asr = await transcribe.execute({ path: result.media_path, model: "tiny" });
-              audioEvidence.push(asr.success ? String(asr.llmContent || asr.output || "").slice(0, 3e3) : `ASR unavailable: ${asr.error}`);
+              if (asr.success) {
+                const transcript = typeof asr.llmContent === "string" ? asr.llmContent.trim() : "";
+                audioEvidence.push(transcript ? transcript.slice(0, 3e3) : "ASR completed: no speech detected");
+              } else {
+                audioEvidence.push(`ASR unavailable: ${asr.error}`);
+              }
             } catch (err) {
               audioEvidence.push(`ASR failed: ${err instanceof Error ? err.message : String(err)}`);
             }
@@ -601681,7 +601886,8 @@ __export(image_ascii_preview_exports, {
   buildImageAsciiPreview: () => buildImageAsciiPreview,
   defaultAsciiPreviewSize: () => defaultAsciiPreviewSize,
   extractSavedImagePath: () => extractSavedImagePath,
-  formatImageAsciiContext: () => formatImageAsciiContext
+  formatImageAsciiContext: () => formatImageAsciiContext,
+  isLowInformationAsciiPreview: () => isLowInformationAsciiPreview
 });
 import { createRequire as createRequire5 } from "node:module";
 import { existsSync as existsSync108, readFileSync as readFileSync87, statSync as statSync42 } from "node:fs";
@@ -601694,10 +601900,13 @@ function defaultAsciiPreviewSize(dimensions) {
   const columns = process.stdout.columns || 100;
   const rows = process.stdout.rows || 32;
   const width = clamp7(columns - 14, 42, 96);
-  const imageAspect = dimensions && dimensions.width > 0 && dimensions.height > 0 ? dimensions.height / dimensions.width : 1;
-  const height = clamp7(Math.min(Math.round(width * imageAspect * TERMINAL_CELL_ASPECT), rows - 10), 8, 42);
+  const height = defaultAsciiPreviewHeight(width, dimensions, rows);
   return { width, height };
 }
+function defaultAsciiPreviewHeight(width, dimensions, rows = process.stdout.rows || 32) {
+  const imageAspect = dimensions && dimensions.width > 0 && dimensions.height > 0 ? dimensions.height / dimensions.width : 1;
+  return clamp7(Math.min(Math.round(width * imageAspect * TERMINAL_CELL_ASPECT), rows - 10), 8, 42);
+}
 function readImageDimensions2(imagePath) {
   try {
     const buf = readFileSync87(imagePath);
@@ -601846,6 +602055,15 @@ function normalizeImageToAsciiResult(converted, width, height) {
   if (!ascii2) return { ascii: null, error: "empty normalized renderer output" };
   return { ascii: ascii2, plainAscii: plainAscii || void 0 };
 }
+function isLowInformationAsciiPreview(ascii2) {
+  const plain = stripAsciiAnsi(String(ascii2 ?? "")).replace(/\r/g, "").split("\n").map((line) => line.trimEnd()).filter((line) => line.trim().length > 0).join("\n");
+  if (!plain) return true;
+  const visible = plain.replace(/\s/g, "");
+  if (visible.length < 12) return true;
+  const unique2 = new Set(Array.from(visible));
+  if (unique2.size <= 2 && /[█▓▒░#@]/u.test(visible)) return true;
+  return false;
+}
 function previewFailure(message2, width) {
   const clean5 = message2.replace(/\s+/g, " ").trim();
   const text2 = `[image-to-ascii preview failed: ${clean5 || "unknown error"}]`;
@@ -601959,15 +602177,19 @@ async function buildImageAsciiPreview(inputPath, options2 = {}) {
   const dimensions = readImageDimensions2(imagePath);
   const defaults3 = defaultAsciiPreviewSize(dimensions);
   const width = clamp7(options2.width ?? defaults3.width, 24, 140);
-  const height = clamp7(options2.height ?? defaults3.height, 6, 60);
+  const height = clamp7(options2.height ?? defaultAsciiPreviewHeight(width, dimensions), 6, 60);
   const timeoutMs = clamp7(options2.timeoutMs ?? 5e3, 500, 3e4);
   if (options2.preferPackage !== false) {
     const result = await convertWithImageToAscii(imagePath, width, height, timeoutMs);
     if (result.ascii) {
+      let plainAscii = result.plainAscii;
+      if (isLowInformationAsciiPreview(plainAscii)) {
+        plainAscii = await convertWithFfmpeg(imagePath, width, height, timeoutMs) ?? plainAscii;
+      }
       return {
         path: imagePath,
         ascii: result.ascii,
-        plainAscii: result.plainAscii,
+        plainAscii,
         renderer: "image-to-ascii",
         width,
         height
@@ -602189,9 +602411,238 @@ function compactSourceId(source) {
   return source.replace(/^\/dev\//, "");
 }
 function truncateCell(value2, width) {
+  value2 = stripDashboardAnsi(String(value2 ?? "")).replace(/\r?\n/g, " ");
   if (width <= 1) return value2.slice(0, Math.max(0, width));
   return value2.length <= width ? value2.padEnd(width, " ") : `${value2.slice(0, Math.max(1, width - 1))}…`;
 }
+function stripDashboardAnsi(value2) {
+  return value2.replace(/\x1B\[[0-?]*[ -/]*[@-~]/g, "");
+}
+function dashboardPreviewLines(camera) {
+  const raw = camera.plainAscii && !isLowInformationAsciiPreview(camera.plainAscii) ? camera.plainAscii : "";
+  return raw.replace(/\r/g, "").split("\n").map((line) => stripDashboardAnsi(line).replace(/\s+$/g, "")).filter((line) => line.trim().length > 0);
+}
+function dashboardPreviewAspect(lines) {
+  const widths = lines.map((line) => stripDashboardAnsi(line).length).filter((n2) => n2 > 0);
+  const maxWidth = Math.max(1, ...widths);
+  return Math.max(0.12, Math.min(1.6, lines.length / maxWidth));
+}
+function fitDashboardPane(lines, paneWidth, paneHeight, fallback) {
+  const source = lines.length > 0 ? lines : [fallback];
+  const normalized = [];
+  for (let i2 = 0; i2 < paneHeight; i2++) {
+    const sourceIndex = source.length <= paneHeight ? i2 : Math.min(source.length - 1, Math.floor(i2 * source.length / paneHeight));
+    normalized.push(truncateCell(source[sourceIndex] ?? "", paneWidth));
+  }
+  while (normalized.length < paneHeight) normalized.push(" ".repeat(paneWidth));
+  return normalized;
+}
+function liveDashboardPaneLayout(width, cameraCount) {
+  const innerWidth = Math.max(10, width - 2);
+  const paneCount = Math.max(1, Math.min(cameraCount || 1, width >= 92 ? 2 : 1));
+  const gutter = paneCount - 1;
+  const paneWidth = Math.max(28, Math.floor((innerWidth - gutter) / paneCount));
+  return { innerWidth, paneCount, paneWidth, paneContentWidth: Math.max(10, paneWidth - 2) };
+}
+function liveDashboardPreviewWidthForSources(sourceCount, termWidth = process.stdout.columns || 100) {
+  const { paneContentWidth } = liveDashboardPaneLayout(Math.max(60, termWidth), sourceCount);
+  return Math.max(42, Math.min(120, paneContentWidth));
+}
+function formatCameraPane(camera, paneWidth, paneHeight, now2) {
+  const contentWidth = Math.max(10, paneWidth - 2);
+  const age = Math.max(0, Math.round((now2 - camera.updatedAt) / 1e3));
+  const title = `${compactSourceId(camera.source)} ${age}s`;
+  const topTitle = ` ${title} `;
+  const left = Math.max(0, Math.floor((contentWidth - topTitle.length) / 2));
+  const right = Math.max(0, contentWidth - topTitle.length - left);
+  const top = `╭${"─".repeat(left)}${topTitle.slice(0, contentWidth)}${"─".repeat(right)}╮`;
+  const bottom = `╰${"─".repeat(contentWidth)}╯`;
+  const previewLines = dashboardPreviewLines(camera);
+  const fallback = camera.framePath ? "preview refreshing" : camera.error ? "capture failed" : "awaiting frame";
+  const body = fitDashboardPane(previewLines, contentWidth, paneHeight, fallback);
+  return [top, ...body.map((line) => `│${truncateCell(line, contentWidth)}│`), bottom];
+}
+function pushDashboardWrapped(lines, value2, width) {
+  const contentWidth = Math.max(10, width - 2);
+  const words = stripDashboardAnsi(value2).replace(/\s+/g, " ").trim().split(" ").filter(Boolean);
+  if (words.length === 0) {
+    lines.push(`│${" ".repeat(contentWidth)}│`);
+    return;
+  }
+  let current = "";
+  for (const word2 of words) {
+    if (!current) {
+      current = word2.length > contentWidth ? word2.slice(0, contentWidth) : word2;
+      continue;
+    }
+    if (current.length + 1 + word2.length <= contentWidth) {
+      current += ` ${word2}`;
+    } else {
+      lines.push(`│${truncateCell(` ${current}`, contentWidth)}│`);
+      current = word2.length > contentWidth ? word2.slice(0, contentWidth) : word2;
+    }
+  }
+  if (current) lines.push(`│${truncateCell(` ${current}`, contentWidth)}│`);
+}
+function isAudioFailureText(value2) {
+  const text2 = String(value2 ?? "").trim();
+  if (!text2) return false;
+  return /^(?:ASR|VAD|Transcription)\s+(?:failed|unavailable)|No module named ['"]?transcribe_cli|torchcodec|torchaudio version/i.test(text2);
+}
+function readPcm16WavActivity(filePath, bins = 36) {
+  try {
+    const buf = readFileSync88(filePath);
+    if (buf.length < 44 || buf.toString("ascii", 0, 4) !== "RIFF" || buf.toString("ascii", 8, 12) !== "WAVE") return void 0;
+    let offset = 12;
+    let channels = 1;
+    let bitsPerSample = 16;
+    let dataStart = -1;
+    let dataSize = 0;
+    while (offset + 8 <= buf.length) {
+      const id2 = buf.toString("ascii", offset, offset + 4);
+      const size = buf.readUInt32LE(offset + 4);
+      const start2 = offset + 8;
+      if (id2 === "fmt " && start2 + 16 <= buf.length) {
+        channels = Math.max(1, buf.readUInt16LE(start2 + 2));
+        bitsPerSample = buf.readUInt16LE(start2 + 14);
+      } else if (id2 === "data") {
+        dataStart = start2;
+        dataSize = Math.min(size, buf.length - start2);
+        break;
+      }
+      offset = start2 + size + size % 2;
+    }
+    if (dataStart < 0 || dataSize <= 0 || bitsPerSample !== 16) return void 0;
+    const frameBytes = channels * 2;
+    const frames = Math.floor(dataSize / frameBytes);
+    if (frames <= 0) return void 0;
+    let sumSquares = 0;
+    let peak = 0;
+    let active = 0;
+    const bucketSquares = new Array(Math.max(1, bins)).fill(0);
+    const bucketCounts = new Array(Math.max(1, bins)).fill(0);
+    for (let i2 = 0; i2 < frames; i2++) {
+      let sampleSum = 0;
+      for (let ch = 0; ch < channels; ch++) {
+        sampleSum += buf.readInt16LE(dataStart + i2 * frameBytes + ch * 2) / 32768;
+      }
+      const sample = sampleSum / channels;
+      const abs = Math.abs(sample);
+      peak = Math.max(peak, abs);
+      sumSquares += sample * sample;
+      if (abs > 0.018) active++;
+      const b = Math.min(bucketSquares.length - 1, Math.floor(i2 / frames * bucketSquares.length));
+      bucketSquares[b] += sample * sample;
+      bucketCounts[b] += 1;
+    }
+    const rms = Math.sqrt(sumSquares / frames);
+    const chars = "▁▂▃▄▅▆▇█";
+    const waveform = bucketSquares.map((sum, idx) => {
+      const count = Math.max(1, bucketCounts[idx] ?? 1);
+      const level = Math.sqrt(sum / count);
+      const normalized = Math.max(0, Math.min(1, level / Math.max(0.02, peak || 0.02)));
+      return chars[Math.min(chars.length - 1, Math.round(normalized * (chars.length - 1)))] ?? "▁";
+    }).join("");
+    return {
+      rms: Number(rms.toFixed(4)),
+      peak: Number(peak.toFixed(4)),
+      rmsDb: Number((20 * Math.log10(Math.max(1e-6, rms))).toFixed(1)),
+      activeRatio: Number((active / frames).toFixed(3)),
+      waveform
+    };
+  } catch {
+    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;
+  const intended = parsed["intended_for_agent"] ?? parsed["intendedForAgent"] ?? parsed["addressed_to_agent"];
+  const confidence2 = Math.max(0, Math.min(1, Number(parsed["confidence"] ?? 0)));
+  if (typeof intended !== "boolean" || !Number.isFinite(confidence2)) return null;
+  const actionRaw = String(parsed["action"] ?? (intended ? "respond" : "ignore")).toLowerCase();
+  const action = actionRaw === "respond" || actionRaw === "monitor" || actionRaw === "ignore" ? actionRaw : intended ? "respond" : "ignore";
+  return {
+    intendedForAgent: intended,
+    confidence: confidence2,
+    action,
+    reason: trimOneLine(parsed["reason"] ?? "", 220) || "intake classifier decision"
+  };
+}
+function fallbackLiveAudioIntakeDecision(transcript) {
+  const text2 = transcript.toLowerCase();
+  const addressed = /\b(omnius|hey\s+omnius|assistant|agent|computer)\b/.test(text2) || /\?$/.test(transcript.trim());
+  return {
+    intendedForAgent: addressed,
+    confidence: addressed ? 0.58 : 0.35,
+    action: addressed ? "respond" : "monitor",
+    reason: addressed ? "fallback detected direct address or question shape" : "fallback could not establish that ambient speech was addressed to Omnius"
+  };
+}
+async function classifyLiveAudioIntake(transcript, config) {
+  const now2 = Date.now();
+  const clean5 = transcript.trim();
+  if (!clean5) {
+    return {
+      intendedForAgent: false,
+      confidence: 1,
+      action: "ignore",
+      reason: "empty transcript",
+      source: "fallback",
+      updatedAt: now2
+    };
+  }
+  if (config?.backendUrl && config.model) {
+    const url = `${config.backendUrl.replace(/\/+$/, "")}/v1/chat/completions`;
+    const body = {
+      model: config.model,
+      temperature: 0,
+      max_tokens: 180,
+      think: false,
+      messages: [
+        {
+          role: "system",
+          content: [
+            "You are a live-audio intake classifier for Omnius.",
+            "Decide whether a transcribed utterance is intended for the agent or is ambient/background speech.",
+            'Return only JSON: {"intended_for_agent": boolean, "confidence": 0.0-1.0, "action": "respond"|"ignore"|"monitor", "reason": "brief evidence"}.',
+            "Do not answer the utterance. Do not treat all room speech as addressed to the agent."
+          ].join("\n")
+        },
+        { role: "user", content: clean5.slice(0, 1200) }
+      ]
+    };
+    try {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), 6e3).unref();
+      const resp = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...config.apiKey ? { Authorization: `Bearer ${config.apiKey}` } : {}
+        },
+        body: JSON.stringify(body),
+        signal: controller.signal
+      });
+      clearTimeout(timer);
+      if (resp.ok) {
+        const json = await resp.json();
+        const content = json.choices?.[0]?.message?.content ?? "";
+        const parsed = parseLiveAudioIntakeDecision(content);
+        if (parsed) return { ...parsed, source: "intake-agent", updatedAt: now2 };
+      }
+    } catch {
+    }
+  }
+  return { ...fallbackLiveAudioIntakeDecision(clean5), source: "fallback", updatedAt: now2 };
+}
 function summarizeInference(value2) {
   if (!value2) return "objects: pending";
   const lines = value2.split("\n").map((line) => line.trim()).filter(Boolean);
@@ -602224,41 +602675,53 @@ function formatLiveDashboardFromSnapshot(snapshot, opts = {}) {
   if (cameras.length === 0) {
     lines.push(`│${truncateCell(" no camera frames captured yet", width - 2)}│`);
   }
+  if (cameras.length > 0) {
+    lines.push(`├${horizontal}┤`);
+    const { innerWidth, paneCount, paneWidth, paneContentWidth } = liveDashboardPaneLayout(width, cameras.length);
+    for (let start2 = 0; start2 < cameras.length; start2 += paneCount) {
+      const group = cameras.slice(start2, start2 + paneCount);
+      const sourceLines = group.map((camera) => dashboardPreviewLines(camera));
+      const aspect = Math.max(0.22, Math.min(0.7, Math.max(...sourceLines.map(dashboardPreviewAspect))));
+      const paneHeight = Math.max(10, Math.min(32, Math.round(paneContentWidth * aspect)));
+      const panes = group.map((camera) => formatCameraPane(camera, paneWidth, paneHeight, now2));
+      const rowCount = Math.max(...panes.map((pane) => pane.length));
+      for (let row = 0; row < rowCount; row++) {
+        const body = panes.map((pane) => pane[row] ?? " ".repeat(paneWidth)).join(" ");
+        lines.push(`│${truncateCell(body, innerWidth)}│`);
+      }
+    }
+  }
+  if (cameras.length > 0) {
+    lines.push(`├${horizontal}┤`);
+    lines.push(`│${truncateCell(" camera observations", width - 2)}│`);
+  }
   for (const camera of cameras) {
     const age = Math.max(0, Math.round((now2 - camera.updatedAt) / 1e3));
     const rotation = camera.orientation ? formatCameraRotation(camera.orientation.rotation) : "upright/no correction";
-    lines.push(`├${horizontal}┤`);
-    lines.push(`│${truncateCell(` ${compactSourceId(camera.source)}  age=${age}s  rotation=${rotation}`, width - 2)}│`);
-    const asciiLines = (camera.ascii ?? "").split("\n").filter((line) => line.length > 0).slice(0, 10);
     const detailLines = [
+      `${compactSourceId(camera.source)} age=${age}s rotation=${rotation}`,
       cameraSnapshotSummary(camera),
       camera.framePath ? `frame: ${camera.displayPath || camera.framePath}` : "",
       camera.orientation?.evidence ? `orientation: ${trimOneLine(camera.orientation.evidence, 120)}` : ""
     ].filter(Boolean);
-    if (asciiLines.length === 0) {
-      for (const detail of detailLines.length ? detailLines : ["preview pending"]) {
-        lines.push(`│${truncateCell(` ${detail}`, width - 2)}│`);
-      }
-      continue;
-    }
-    const imageWidth = Math.max(24, Math.min(52, Math.floor((width - 5) * 0.58)));
-    const detailWidth = Math.max(18, width - imageWidth - 5);
-    const rowCount = Math.max(asciiLines.length, detailLines.length);
-    for (let i2 = 0; i2 < rowCount; i2++) {
-      const image = truncateCell(asciiLines[i2] ?? "", imageWidth);
-      const detail = truncateCell(detailLines[i2] ?? "", detailWidth);
-      lines.push(`│ ${image} │ ${detail}│`);
+    for (const detail of detailLines.length ? detailLines : ["preview pending"]) {
+      pushDashboardWrapped(lines, detail, width);
     }
   }
   if (snapshot.audio) {
     lines.push(`├${horizontal}┤`);
+    const transcriptFailure = isAudioFailureText(snapshot.audio.transcript) ? snapshot.audio.transcript : "";
+    const transcript = transcriptFailure ? "" : snapshot.audio.transcript;
+    const audioError = [snapshot.audio.error, transcriptFailure].filter(Boolean).join(" | ");
     const audioBits = [
       `audio input=${snapshot.audio.input || snapshot.config.selectedAudioInput || "none"}`,
-      snapshot.audio.error ? `error=${trimOneLine(snapshot.audio.error, 120)}` : "",
-      snapshot.audio.transcript ? `asr=${trimOneLine(snapshot.audio.transcript, 120)}` : "",
+      snapshot.audio.activity ? `activity ${snapshot.audio.activity.waveform} rms=${snapshot.audio.activity.rmsDb.toFixed(1)}dB active=${Math.round(snapshot.audio.activity.activeRatio * 100)}%` : "",
+      audioError ? `error=${trimOneLine(audioError, 120)}` : "",
+      transcript ? `asr${snapshot.audio.asrBackend ? `(${snapshot.audio.asrBackend})` : ""}=${trimOneLine(transcript, 120)}` : "",
+      snapshot.audio.intake ? `intake=${snapshot.audio.intake.intendedForAgent ? "for-agent" : "ambient"} conf=${snapshot.audio.intake.confidence.toFixed(2)} ${snapshot.audio.intake.action}` : "",
       snapshot.audio.analysis ? `sound=${trimOneLine(snapshot.audio.analysis, 120)}` : ""
     ].filter(Boolean);
-    for (const item of audioBits.slice(0, 4)) lines.push(`│${truncateCell(` ${item}`, width - 2)}│`);
+    for (const item of audioBits.slice(0, 6)) lines.push(`│${truncateCell(` ${item}`, width - 2)}│`);
   }
   lines.push(`╰${horizontal}╯`);
   return lines;
@@ -602607,6 +603070,9 @@ function formatLiveSensorContextFromSnapshot(snapshot, opts = {}) {
     }
   }
   if (snapshot.audio) {
+    const transcriptFailure = isAudioFailureText(snapshot.audio.transcript) ? snapshot.audio.transcript : "";
+    const transcript = transcriptFailure ? "" : snapshot.audio.transcript;
+    const audioError = [snapshot.audio.error, transcriptFailure].filter(Boolean).join(" | ");
     const audioEvents = (snapshot.events ?? []).filter((event) => event.kind === "audio_transcript" || event.kind === "audio_sound").sort((a2, b) => b.observedAt - a2.observedAt).slice(0, 8);
     if (audioEvents.length > 0) {
       lines.push("");
@@ -602623,11 +603089,18 @@ function formatLiveSensorContextFromSnapshot(snapshot, opts = {}) {
     lines.push("");
     lines.push("## LIVE AUDIO LATEST SAMPLE");
     lines.push(`timestamp: ${nowIso3(snapshot.audio.updatedAt)} age=${Math.max(0, Math.round(age / 1e3))}s${age > maxAgeMs ? " STALE" : ""}`);
-    if (snapshot.audio.error) lines.push(`error: ${snapshot.audio.error}`);
+    if (audioError) lines.push(`error: ${audioError}`);
     if (snapshot.audio.recordingPath) lines.push(`recording: ${snapshot.audio.recordingPath}`);
-    if (snapshot.audio.transcript) {
-      lines.push("Live ASR:");
-      lines.push(cleanPreview(snapshot.audio.transcript, 1200));
+    if (snapshot.audio.activity) {
+      lines.push(`activity: ${snapshot.audio.activity.waveform} rms_db=${snapshot.audio.activity.rmsDb.toFixed(1)} peak=${snapshot.audio.activity.peak.toFixed(3)} active=${Math.round(snapshot.audio.activity.activeRatio * 100)}%`);
+    }
+    if (transcript) {
+      lines.push(`Live ASR${snapshot.audio.asrBackend ? ` (${snapshot.audio.asrBackend})` : ""}:`);
+      lines.push(cleanPreview(transcript, 1200));
+    }
+    if (snapshot.audio.intake) {
+      lines.push(`Live audio intake: intended_for_agent=${snapshot.audio.intake.intendedForAgent ? "true" : "false"} confidence=${snapshot.audio.intake.confidence.toFixed(2)} action=${snapshot.audio.intake.action} source=${snapshot.audio.intake.source}`);
+      lines.push(`intake_reason: ${snapshot.audio.intake.reason}`);
     }
     if (snapshot.audio.analysis) {
       lines.push("Live sound analysis:");
@@ -602890,6 +603363,7 @@ var init_live_sensors = __esm({
       lastAgentReviewAt = 0;
       autoOrientationInFlight = /* @__PURE__ */ new Set();
       lastFeedbackAt = /* @__PURE__ */ new Map();
+      intakeAgentConfig;
       setStatusSink(sink) {
         this.statusSink = sink ?? null;
         this.emitStatus();
@@ -602900,6 +603374,9 @@ var init_live_sensors = __esm({
       setAgentActionSink(sink) {
         this.agentActionSink = sink ?? null;
       }
+      setAudioIntakeAgentConfig(config) {
+        this.intakeAgentConfig = config && config.backendUrl && config.model ? { backendUrl: config.backendUrl, model: config.model, apiKey: config.apiKey } : void 0;
+      }
       getConfig() {
         return { ...this.config };
       }
@@ -603195,7 +603672,8 @@ var init_live_sensors = __esm({
         const framePath = extractSavedImagePath(result.output, this.repoRoot);
         if (!framePath) return { ok: false, message: "Camera capture succeeded but no saved image path was returned." };
         const displayPath = relative11(this.repoRoot, framePath).startsWith("..") ? framePath : relative11(this.repoRoot, framePath);
-        const preview = await buildImageAsciiPreview(framePath, { width: 72, height: 22 });
+        const previewWidth = Math.max(42, Math.min(120, Math.floor(Number(options2.previewWidth ?? (process.stdout.columns || 100) - 14))));
+        const preview = await buildImageAsciiPreview(framePath, { width: previewWidth });
         const asciiContext = preview ? formatImageAsciiContext(preview, displayPath) : void 0;
         const observedAt = Date.now();
         const cameraView = {
@@ -603204,6 +603682,7 @@ var init_live_sensors = __esm({
           framePath,
           displayPath,
           ascii: preview?.ascii,
+          plainAscii: preview?.plainAscii,
           renderer: preview?.renderer,
           asciiContext,
           rotation,
@@ -603237,6 +603716,7 @@ var init_live_sensors = __esm({
             imagePath: framePath,
             displayPath,
             ascii: preview?.ascii,
+            plainAscii: preview?.plainAscii,
             renderer: preview?.renderer
           });
         }
@@ -603246,6 +603726,7 @@ var init_live_sensors = __esm({
           framePath,
           displayPath,
           ascii: preview?.ascii,
+          plainAscii: preview?.plainAscii,
           renderer: preview?.renderer
         };
       }
@@ -603291,8 +603772,8 @@ var init_live_sensors = __esm({
           return message2;
         }
       }
-      async sampleSingleVideoNow(source, forceInfer) {
-        const preview = await this.previewCamera(source, { emit: false });
+      async sampleSingleVideoNow(source, forceInfer, previewWidth) {
+        const preview = await this.previewCamera(source, { emit: false, previewWidth });
         let inference = "";
         let clipSummary = "";
         const orientation = this.getCameraOrientation(source);
@@ -603381,8 +603862,9 @@ ${clipSummary}` : ""].filter(Boolean).join("\n");
           const sources = this.activeVideoSources();
           if (sources.length === 0) return "No camera selected. Use /live refresh after connecting hardware.";
           const outputs = [];
+          const previewWidth = liveDashboardPreviewWidthForSources(sources.length);
           for (const source of sources) {
-            outputs.push(await this.sampleSingleVideoNow(source, forceInfer));
+            outputs.push(await this.sampleSingleVideoNow(source, forceInfer, previewWidth));
           }
           this.emitDashboard();
           return outputs.map((output, index) => `## Camera ${sources[index]}
@@ -603400,7 +603882,10 @@ ${output}`).join("\n\n");
           ensureLiveDir(this.repoRoot);
           const recordingPath = join124(outputDir2, `audio-${Date.now()}.wav`);
           let transcript = "";
+          let asrBackend = "";
           let analysis = "";
+          let intake;
+          const audioErrors = [];
           const capture = await recordAudioSampleWithRecovery(input, this.devices.audioInputs, 3, recordingPath);
           if (!capture.ok) {
             const message2 = `Audio capture failed from ${input}; tried fallbacks: ${capture.errors.slice(0, 5).join(" | ")}`;
@@ -603423,12 +603908,18 @@ ${output}`).join("\n\n");
           if (capture.device !== this.config.selectedAudioInput) {
             this.config.selectedAudioInput = capture.device;
           }
+          const activity = readPcm16WavActivity(recordingPath);
           if (this.config.asrEnabled) {
             try {
               const asr = await new TranscribeFileTool(this.repoRoot).execute({ path: recordingPath, model: "tiny" });
-              transcript = asr.success ? cleanPreview(asr.llmContent || asr.output, 1600) : `ASR failed: ${asr.error || asr.output || "unknown error"}`;
+              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) {
-              transcript = `ASR failed: ${err instanceof Error ? err.message : String(err)}`;
+              audioErrors.push(`ASR unavailable: ${err instanceof Error ? err.message : String(err)}`);
             }
           }
           if (this.config.audioAnalysisEnabled) {
@@ -603442,19 +603933,27 @@ ${output}`).join("\n\n");
             }
             try {
               const vad = await analyzer.execute({ action: "vad", file: recordingPath });
-              parts.push(vad.success ? cleanPreview(vad.output, 700) : `vad failed: ${vad.error}`);
+              if (vad.success) parts.push(cleanPreview(vad.output, 700));
+              else audioErrors.push(`VAD unavailable: ${vad.error || vad.output || "unknown error"}`);
             } catch (err) {
-              parts.push(`vad failed: ${err instanceof Error ? err.message : String(err)}`);
+              audioErrors.push(`VAD unavailable: ${err instanceof Error ? err.message : String(err)}`);
             }
             analysis = parts.filter(Boolean).join("\n");
           }
+          if (transcript) {
+            intake = await classifyLiveAudioIntake(transcript, this.intakeAgentConfig);
+          }
           this.snapshot.audio = {
             updatedAt: Date.now(),
             input: capture.device,
             output: this.config.selectedAudioOutput,
             recordingPath,
             transcript,
-            analysis
+            asrBackend: asrBackend || void 0,
+            analysis,
+            activity,
+            intake,
+            error: audioErrors.length > 0 ? audioErrors.join("\n") : void 0
           };
           const audioEvents = [];
           if (transcript) {
@@ -603481,12 +603980,20 @@ ${output}`).join("\n\n");
           }
           this.snapshot.events = mergeRecentById(this.snapshot.events, audioEvents, 50);
           this.persist();
+          if (transcript && intake?.intendedForAgent) {
+            this.maybeRequestAgentReview(
+              "Live audio intake classified speech as intended for Omnius",
+              `transcript=${transcript}; confidence=${intake.confidence.toFixed(2)}; reason=${intake.reason}`
+            );
+          }
           this.emitDashboard();
           return [
             `Audio sample captured from ${capture.device}${capture.device !== input ? ` (recovered from ${input})` : ""}: ${recordingPath}`,
             transcript ? `
-ASR:
+ASR${asrBackend ? ` (${asrBackend})` : ""}:
 ${transcript}` : "",
+            intake ? `
+Intake: ${intake.intendedForAgent ? "intended for agent" : "ambient/monitor"} confidence=${intake.confidence.toFixed(2)} (${intake.source})` : "",
             analysis ? `
 Sound analysis:
 ${analysis}` : ""
@@ -624102,15 +624609,6 @@ var init_status_bar = __esm({
           const cmdPrefix = cmd.startsWith("view:") ? "omnius-view:" + cmd.slice(5) : "omnius-cmd:" + cmd;
           return `\x1B]8;;${cmdPrefix}\x07${label}\x1B]8;;\x07`;
         };
-        const buttonFg = (cmd) => {
-          let fg2 = TEXT_DIM;
-          if (cmd === "voice" && this._voiceActive) fg2 = 82;
-          if (cmd.startsWith("live") && (this._liveMediaStatus.audio || this._liveMediaStatus.video)) fg2 = 82;
-          if (cmd === "nexus") {
-            fg2 = this._nexusStatus === "connected" ? 82 : this._nexusStatus === "connecting" ? 208 : 196;
-          }
-          return fg2;
-        };
         const decorateMenuButton = (cmd, label) => {
           return `${HEADER_BUTTON_GLYPH_FG}${HEADER_BUTTON_LEFT}\x1B[0m${HEADER_BUTTON_BG}${HEADER_BUTTON_FG}${label}\x1B[0m${PANEL_BG_SEQ}${HEADER_BUTTON_GLYPH_FG}${HEADER_BUTTON_RIGHT}\x1B[0m${PANEL_BG_SEQ}`;
         };
@@ -624121,14 +624619,7 @@ var init_status_bar = __esm({
           return `\x1B[38;5;${color}m${HEADER_BUTTON_LEFT}\x1B[0m${weight}${fg2}${bg}${content}\x1B[0m${PANEL_BG_SEQ}\x1B[38;5;${color}m${HEADER_BUTTON_RIGHT}\x1B[0m${PANEL_BG_SEQ}`;
         };
         const renderBtn = (cmd, label) => {
-          const fg2 = buttonFg(cmd);
-          const btnW = label.length + 2;
-          const availW2 = getTermWidth() - identity3.width - 1;
-          if (btnW > availW2) return linkify(cmd, `\x1B[38;5;${fg2}m${label}`);
-          return linkify(
-            cmd,
-            `${PANEL_BG_SEQ}${HEADER_BUTTON_GLYPH_FG}${HEADER_BUTTON_LEFT}\x1B[0m${PANEL_BG_SEQ}\x1B[38;5;${fg2}m${label}\x1B[0m${PANEL_BG_SEQ}${HEADER_BUTTON_GLYPH_FG}${HEADER_BUTTON_RIGHT}\x1B[0m${PANEL_BG_SEQ}`
-          );
+          return linkify(cmd, decorateMenuButton(cmd, label));
         };
         const identity3 = this.buildHeaderIdentityRender();
         const modelLabel = this.summarizeHeaderModelName() || "model";
@@ -624201,10 +624692,9 @@ var init_status_bar = __esm({
         };
         if (this._activeViewId !== "main") {
           const mainLabel = ` ↩ main `;
-          const mainColored = `\x1B[38;5;110m${mainLabel}\x1B[0m`;
           sysItems.push({
-            render: () => mainColored + " ",
-            w: mainLabel.length + 1
+            render: () => linkify("view:main", decorateMenuButton("view:main", mainLabel)) + " ",
+            w: mainLabel.length + 2 + 1
           });
         }
         if (this._agentViews.size > 1) {
@@ -624242,10 +624732,7 @@ var init_status_bar = __esm({
         const telegramDot = this._telegramStatus.active ? "●" : "○";
         const telegramLabel = this._telegramStatus.activeSubAgents > 0 ? ` ✈ tg ${this._telegramStatus.activeSubAgents} ` : " ✈ tg ";
         sysItems.push({
-          render: () => renderBtn(
-            "telegram",
-            `${HEADER_TELEGRAM_FG}${telegramDot}${telegramLabel}\x1B[0m`
-          ) + " ",
+          render: () => renderBtn("telegram", `${telegramDot}${telegramLabel}`) + " ",
           w: telegramLabel.length + 2
         });
         const liveMediaActive = this._liveMediaStatus.audio || this._liveMediaStatus.video;
@@ -624390,7 +624877,7 @@ var init_status_bar = __esm({
           const trunc3 = (s2) => s2.trim().split(/\s+/).slice(0, 3).join(" ");
           if (this._activeViewId !== "main") {
             const mainLabel = ` ↩ main `;
-            zones.push({ w: mainLabel.length + 1, id: "main", render: () => "" });
+            zones.push({ w: mainLabel.length + 2 + 1, id: "main", render: () => "" });
           }
           if (this._agentViews.size > 1) {
             for (const view of this._agentViews.values()) {
@@ -655292,12 +655779,17 @@ function renderLiveFeedback(ctx3, manager, feedback) {
     return;
   }
   const stamp = new Date(feedback.observedAt).toISOString();
+  const explicitImagePreview = (feedback.kind === "camera-frame" || feedback.kind === "face-crop") && feedback.ascii && feedback.displayPath && feedback.renderer;
+  if (ctx3.liveDynamicBlockHost && !explicitImagePreview) {
+    renderLiveDashboard(ctx3, manager);
+    return;
+  }
   if (feedback.kind === "error") {
     renderWarning(`[live ${stamp}] ${feedback.title}
 ${feedback.message}`);
     return;
   }
-  if ((feedback.kind === "camera-frame" || feedback.kind === "face-crop") && feedback.ascii && feedback.displayPath && feedback.renderer) {
+  if (explicitImagePreview && feedback.displayPath && feedback.ascii && feedback.renderer) {
     renderInfo(`[live ${stamp}] ${feedback.message}`);
     renderImageAsciiPreview(feedback.title, feedback.displayPath, feedback.ascii, feedback.renderer);
     return;
@@ -655308,6 +655800,11 @@ ${feedback.message}`);
 function attachLiveSinks(ctx3, manager, agentEnabled = false) {
   manager.setStatusSink(ctx3.setLiveMediaStatus);
   manager.setFeedbackSink((feedback) => renderLiveFeedback(ctx3, manager, feedback));
+  manager.setAudioIntakeAgentConfig({
+    backendUrl: ctx3.config.backendUrl,
+    model: ctx3.config.model,
+    apiKey: ctx3.config.apiKey
+  });
   if (agentEnabled && ctx3.startBackgroundPrompt) {
     manager.setAgentActionSink((prompt) => {
       const id2 = ctx3.startBackgroundPrompt?.(prompt);
@@ -733836,6 +734333,8 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
             } else {
               parts.push("active: no");
             }
+            const liveContext = formatLiveSensorContext(repoRoot);
+            if (liveContext) parts.push(liveContext);
             return parts.join("\n");
           }
         },

package/npm-shrinkwrap.json

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

package/package.json

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