omnius 1.0.408 → 1.0.409

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)}`);
             }
@@ -601694,10 +601899,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);
@@ -601959,7 +602167,7 @@ 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);
@@ -602189,9 +602397,66 @@ 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 || camera.ascii || "";
+  return raw.replace(/\r/g, "").split("\n").map((line) => stripDashboardAnsi(line).replace(/\s+$/g, "")).filter((line) => line.trim().length > 0).slice(0, 10);
+}
+function centerDashboardCell(value2, width) {
+  const text2 = stripDashboardAnsi(String(value2 ?? "")).replace(/\r?\n/g, " ");
+  if (width <= 1) return text2.slice(0, Math.max(0, width));
+  const clipped = text2.length > width ? `${text2.slice(0, Math.max(1, width - 1))}…` : text2;
+  const left = Math.floor((width - clipped.length) / 2);
+  return `${" ".repeat(Math.max(0, left))}${clipped}${" ".repeat(Math.max(0, width - clipped.length - left))}`;
+}
+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) {
+  const source = lines.length > 0 ? lines : ["preview pending"];
+  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 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 summarizeInference(value2) {
   if (!value2) return "objects: pending";
   const lines = value2.split("\n").map((line) => line.trim()).filter(Boolean);
@@ -602224,38 +602489,54 @@ 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 paneCount = Math.min(cameras.length, width >= 116 ? 3 : width >= 78 ? 2 : 1);
+    const innerWidth = width - 2;
+    const gutter = paneCount - 1;
+    const paneWidth = Math.max(24, Math.floor((innerWidth - gutter) / paneCount));
+    for (let start2 = 0; start2 < cameras.length; start2 += paneCount) {
+      const group = cameras.slice(start2, start2 + paneCount);
+      const sourceLines = group.map((camera) => dashboardPreviewLines(camera));
+      const paneHeight = Math.max(7, Math.min(22, Math.round(paneWidth * Math.max(...sourceLines.map(dashboardPreviewAspect)))));
+      const panes = sourceLines.map((previewLines) => fitDashboardPane(previewLines, paneWidth, paneHeight));
+      for (let row = 0; row < paneHeight; row++) {
+        const body = panes.map((pane) => pane[row] ?? " ".repeat(paneWidth)).join(" ");
+        lines.push(`│${truncateCell(body, innerWidth)}│`);
+      }
+      const labels = group.map((camera) => {
+        const age = Math.max(0, Math.round((now2 - camera.updatedAt) / 1e3));
+        return centerDashboardCell(`${compactSourceId(camera.source)} age=${age}s`, paneWidth);
+      }).join(" ");
+      lines.push(`│${truncateCell(labels, 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)}` : "",
+      audioError ? `error=${trimOneLine(audioError, 120)}` : "",
+      transcript ? `asr=${trimOneLine(transcript, 120)}` : "",
       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)}│`);
@@ -602607,6 +602888,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 +602907,11 @@ 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) {
+    if (transcript) {
       lines.push("Live ASR:");
-      lines.push(cleanPreview(snapshot.audio.transcript, 1200));
+      lines.push(cleanPreview(transcript, 1200));
     }
     if (snapshot.audio.analysis) {
       lines.push("Live sound analysis:");
@@ -603195,7 +603479,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(48, Math.min(96, (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 +603489,7 @@ var init_live_sensors = __esm({
           framePath,
           displayPath,
           ascii: preview?.ascii,
+          plainAscii: preview?.plainAscii,
           renderer: preview?.renderer,
           asciiContext,
           rotation,
@@ -603401,6 +603687,7 @@ ${output}`).join("\n\n");
           const recordingPath = join124(outputDir2, `audio-${Date.now()}.wav`);
           let transcript = "";
           let analysis = "";
+          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(" | ")}`;
@@ -603426,9 +603713,13 @@ ${output}`).join("\n\n");
           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);
+              } 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,9 +603733,10 @@ ${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");
           }
@@ -603454,7 +603746,8 @@ ${output}`).join("\n\n");
             output: this.config.selectedAudioOutput,
             recordingPath,
             transcript,
-            analysis
+            analysis,
+            error: audioErrors.length > 0 ? audioErrors.join("\n") : void 0
           };
           const audioEvents = [];
           if (transcript) {
@@ -655292,12 +655585,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;
@@ -733836,6 +734134,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.409",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "omnius",
-      "version": "1.0.408",
+      "version": "1.0.409",
       "bundleDependencies": [
         "image-to-ascii"
       ],

package/package.json

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