omnius 1.0.416 → 1.0.418

package/dist/index.js

@@ -41899,7 +41899,7 @@ var init_transcribe_tool = __esm({
             "-U",
             "pip",
             "wheel",
-            "setuptools",
+            "setuptools<81",
             "numpy",
             "openai-whisper"
           ], {
@@ -602840,20 +602840,1381 @@ var init_image_ascii_preview = __esm({
   }
 });
 
+// packages/cli/src/api/py-embed.ts
+var py_embed_exports = {};
+__export(py_embed_exports, {
+  ensureEmbedDeps: () => ensureEmbedDeps,
+  getVenvPython: () => getVenvPython,
+  runEmbedAudio: () => runEmbedAudio,
+  runEmbedImage: () => runEmbedImage,
+  runEmbedText: () => runEmbedText,
+  runTranscribeFile: () => runTranscribeFile
+});
+import { spawnSync as spawnSync8 } from "node:child_process";
+import { existsSync as existsSync109, mkdirSync as mkdirSync67, writeFileSync as writeFileSync56 } from "node:fs";
+import { join as join124 } from "node:path";
+import { homedir as homedir38 } from "node:os";
+function getVenvDir() {
+  return join124(homedir38(), ".omnius", "venv");
+}
+function getVenvPython() {
+  const base3 = getVenvDir();
+  const bin = process.platform === "win32" ? "Scripts" : "bin";
+  const exe = process.platform === "win32" ? "python.exe" : "python3";
+  return join124(base3, bin, exe);
+}
+function ensureEmbedDeps() {
+  const venv = getVenvDir();
+  let log22 = "";
+  try {
+    mkdirSync67(venv, { recursive: true });
+  } catch {
+  }
+  const venvExisted = existsSync109(getVenvPython());
+  if (!venvExisted) {
+    const mk = spawnSync8("python3", ["-m", "venv", venv], { encoding: "utf8" });
+    log22 += mk.stdout + mk.stderr;
+  }
+  if (venvExisted && !(process.env["OMNIUS_INSTALL_FULL_EMBED_DEPS"] === "1")) {
+    const check = spawnSync8(
+      getVenvPython(),
+      ["-c", "import numpy, soundfile, whisper, faster_whisper, PIL"],
+      { encoding: "utf8", timeout: 3e4 }
+    );
+    if (check.status === 0) {
+      return { ok: true, log: "embed deps already satisfied" };
+    }
+  }
+  const pip = process.platform === "win32" ? join124(venv, "Scripts", "pip.exe") : join124(venv, "bin", "pip");
+  const up = spawnSync8(pip, ["install", "--upgrade", "pip", "setuptools<81", "wheel"], { encoding: "utf8", timeout: 3e5 });
+  log22 += up.stdout + up.stderr;
+  const asrPkgs = [
+    "numpy==1.26.4",
+    "soundfile",
+    "faster-whisper",
+    "openai-whisper",
+    // Embedding helpers used elsewhere (kept lightweight compared to full torch stack)
+    "Pillow"
+  ];
+  const ins = spawnSync8(pip, ["install", ...asrPkgs], { encoding: "utf8", timeout: 9e5 });
+  log22 += ins.stdout + ins.stderr;
+  let fullOk = true;
+  if (process.env["OMNIUS_INSTALL_FULL_EMBED_DEPS"] === "1") {
+    const fullPkgs = ["torch", "torchaudio", "open_clip_torch", "speechbrain"];
+    const full = spawnSync8(pip, ["install", "--upgrade", ...fullPkgs], { encoding: "utf8", timeout: 18e5 });
+    log22 += full.stdout + full.stderr;
+    fullOk = full.status === 0;
+  }
+  const ok3 = ins.status === 0 && up.status === 0 && fullOk;
+  return { ok: ok3, log: log22 };
+}
+function runEmbedImage(input) {
+  const py = getVenvPython();
+  const script = locateScript("embed-image.py");
+  const p2 = spawnSync8(py, [script], { input: JSON.stringify(input), encoding: "utf8" });
+  try {
+    const out = JSON.parse(p2.stdout || "{}");
+    if (Array.isArray(out.embedding)) return new Float32Array(out.embedding);
+  } catch {
+  }
+  return null;
+}
+function runEmbedAudio(input) {
+  const py = getVenvPython();
+  const script = locateScript("embed-audio.py");
+  const p2 = spawnSync8(py, [script], { input: JSON.stringify(input), encoding: "utf8" });
+  try {
+    const out = JSON.parse(p2.stdout || "{}");
+    if (Array.isArray(out.embedding)) return new Float32Array(out.embedding);
+  } catch {
+  }
+  return null;
+}
+function runEmbedText(text2) {
+  const py = getVenvPython();
+  const script = locateScript("embed-text.py");
+  const p2 = spawnSync8(py, [script], { input: JSON.stringify({ text: text2 }), encoding: "utf8" });
+  try {
+    const out = JSON.parse(p2.stdout || "{}");
+    if (Array.isArray(out.embedding)) return new Float32Array(out.embedding);
+  } catch {
+  }
+  return null;
+}
+function runTranscribeFile(input) {
+  const py = getVenvPython();
+  const script = locateScript("transcribe-file.py");
+  const p2 = spawnSync8(py, [script], { input: JSON.stringify(input), encoding: "utf8", timeout: 6e5 });
+  try {
+    const out = JSON.parse(p2.stdout || "{}");
+    if (typeof out.text === "string") return out.text;
+  } catch {
+  }
+  return null;
+}
+function locateScript(name10) {
+  const candidates = [
+    join124(process.cwd(), "dist", "scripts", name10),
+    join124(process.cwd(), name10),
+    join124(process.cwd(), "scripts", name10)
+  ];
+  for (const c9 of candidates) if (existsSync109(c9)) return c9;
+  const fallback = join124(process.cwd(), name10);
+  try {
+    writeFileSync56(fallback, 'print("missing script")\n');
+  } catch {
+  }
+  return fallback;
+}
+var init_py_embed = __esm({
+  "packages/cli/src/api/py-embed.ts"() {
+    "use strict";
+  }
+});
+
+// packages/cli/src/tui/listen.ts
+var listen_exports = {};
+__export(listen_exports, {
+  ListenEngine: () => ListenEngine,
+  ensureTranscribeCliBackground: () => ensureTranscribeCliBackground,
+  getListenEngine: () => getListenEngine,
+  getListenLiveState: () => getListenLiveState,
+  isAudioPath: () => isAudioPath,
+  isTranscribablePath: () => isTranscribablePath,
+  isVideoPath: () => isVideoPath,
+  transcribeFileViaWhisper: () => transcribeFileViaWhisper,
+  waitForTranscribeCli: () => waitForTranscribeCli
+});
+import { spawn as spawn29 } from "node:child_process";
+import {
+  existsSync as existsSync110,
+  mkdirSync as mkdirSync68,
+  writeFileSync as writeFileSync57,
+  readdirSync as readdirSync35
+} from "node:fs";
+import { join as join125, dirname as dirname37 } from "node:path";
+import { homedir as homedir39 } from "node:os";
+import { fileURLToPath as fileURLToPath16 } from "node:url";
+import { EventEmitter as EventEmitter6 } from "node:events";
+import { createInterface as createInterface2 } from "node:readline";
+function isAudioPath(path12) {
+  const ext = path12.toLowerCase().split(".").pop();
+  return ext ? AUDIO_EXTENSIONS.has(`.${ext}`) : false;
+}
+function isVideoPath(path12) {
+  const ext = path12.toLowerCase().split(".").pop();
+  return ext ? VIDEO_EXTENSIONS2.has(`.${ext}`) : false;
+}
+function isTranscribablePath(path12) {
+  return isAudioPath(path12) || isVideoPath(path12);
+}
+function updateListenLiveState(patch) {
+  Object.assign(listenLiveState, patch, { updatedAt: Date.now() });
+}
+function getListenLiveState() {
+  return listenLiveState;
+}
+async function resolveMicSource() {
+  const configured = String(process.env["OMNIUS_MIC_DEVICE"] ?? "").trim();
+  if (configured.startsWith("hw:") || configured.startsWith("plughw:")) {
+    return { alsaDevice: configured, label: configured };
+  }
+  const configuredPulse = configured.startsWith("pulse:") ? configured.slice("pulse:".length) : configured || void 0;
+  let sources = [];
+  try {
+    const raw = await execFileText4("pactl", ["list", "short", "sources"], { timeout: 5e3 });
+    for (const line of raw.split(/\r?\n/).filter(Boolean)) {
+      const parts = line.split("	");
+      const name10 = parts[1]?.trim();
+      if (!name10) continue;
+      const spec = parts[3] ?? "";
+      const chMatch = spec.match(/(\d+)ch/);
+      sources.push({
+        name: name10,
+        channels: chMatch ? Math.max(1, Number(chMatch[1])) : 1,
+        state: (parts[4] ?? "").trim().toUpperCase()
+      });
+    }
+  } catch {
+    sources = [];
+  }
+  if (configuredPulse) {
+    const match = sources.find((s2) => s2.name === configuredPulse);
+    return {
+      pulseSource: configuredPulse,
+      channels: match?.channels,
+      label: `pulse:${configuredPulse}`
+    };
+  }
+  const candidates = sources.filter((s2) => !/\.monitor$/i.test(s2.name));
+  if (candidates.length === 0) return null;
+  const rank = (s2) => {
+    let score = 0;
+    if (s2.state === "RUNNING") score -= 20;
+    if (s2.state === "SUSPENDED") score += 5;
+    if (/usb|mic|array|respeaker|seeed/i.test(s2.name)) score -= 10;
+    return score;
+  };
+  candidates.sort((a2, b) => rank(a2) - rank(b));
+  const best = candidates[0];
+  return { pulseSource: best.name, channels: best.channels, label: `pulse:${best.name}` };
+}
+function micFfmpegFilter(channels) {
+  const parts = [];
+  if ((channels ?? 1) > 2) parts.push("pan=mono|c0=c0");
+  parts.push("highpass=f=80");
+  const gain2 = Number(process.env["OMNIUS_MIC_GAIN_DB"] ?? "");
+  if (Number.isFinite(gain2) && gain2 !== 0) parts.push(`volume=${gain2}dB`);
+  return parts.join(",");
+}
+async function findMicCaptureCommand() {
+  const platform7 = process.platform;
+  if (platform7 === "linux") {
+    const resolved = await resolveMicSource();
+    if (resolved?.alsaDevice && await commandExists2("arecord")) {
+      return {
+        cmd: "arecord",
+        args: ["-D", resolved.alsaDevice, "-f", "S16_LE", "-r", "16000", "-c", "1", "-t", "raw", "-q", "-"],
+        device: resolved.alsaDevice
+      };
+    }
+    if (resolved?.pulseSource && await commandExists2("ffmpeg")) {
+      return {
+        cmd: "ffmpeg",
+        args: [
+          "-f",
+          "pulse",
+          "-i",
+          resolved.pulseSource,
+          "-af",
+          micFfmpegFilter(resolved.channels),
+          "-ar",
+          "16000",
+          "-ac",
+          "1",
+          "-f",
+          "s16le",
+          "-loglevel",
+          "quiet",
+          "pipe:1"
+        ],
+        device: resolved.label
+      };
+    }
+    if (await commandExists2("arecord")) {
+      return {
+        cmd: "arecord",
+        args: ["-f", "S16_LE", "-r", "16000", "-c", "1", "-t", "raw", "-q", "-"],
+        device: "default (arecord)"
+      };
+    }
+  }
+  if (platform7 === "darwin") {
+    if (await commandExists2("sox")) {
+      return {
+        cmd: "sox",
+        args: [
+          "-d",
+          "-t",
+          "raw",
+          "-r",
+          "16000",
+          "-c",
+          "1",
+          "-b",
+          "16",
+          "-e",
+          "signed-integer",
+          "-"
+        ],
+        device: "default (sox)"
+      };
+    }
+  }
+  if (await commandExists2("ffmpeg")) {
+    if (platform7 === "linux") {
+      return {
+        cmd: "ffmpeg",
+        args: [
+          "-f",
+          "pulse",
+          "-i",
+          "default",
+          "-ar",
+          "16000",
+          "-ac",
+          "1",
+          "-f",
+          "s16le",
+          "-loglevel",
+          "quiet",
+          "pipe:1"
+        ],
+        device: "pulse:default"
+      };
+    } else if (platform7 === "darwin") {
+      return {
+        cmd: "ffmpeg",
+        args: [
+          "-f",
+          "avfoundation",
+          "-i",
+          ":0",
+          "-ar",
+          "16000",
+          "-ac",
+          "1",
+          "-f",
+          "s16le",
+          "-loglevel",
+          "quiet",
+          "pipe:1"
+        ],
+        device: "avfoundation:0"
+      };
+    }
+  }
+  return null;
+}
+async function findTranscribeFileScript() {
+  const thisDir = dirname37(fileURLToPath16(import.meta.url));
+  const candidates = [
+    join125(thisDir, "../../../../packages/execution/scripts/transcribe-file.py"),
+    join125(thisDir, "../../../packages/execution/scripts/transcribe-file.py"),
+    join125(thisDir, "../../execution/scripts/transcribe-file.py"),
+    join125(thisDir, "../scripts/transcribe-file.py"),
+    join125(thisDir, "../../scripts/transcribe-file.py")
+  ];
+  for (const p2 of candidates) {
+    if (existsSync110(p2)) return p2;
+  }
+  try {
+    const globalRoot = (await execFileText4("npm", ["root", "-g"], { timeout: 5e3 })).trim();
+    const candidates2 = [
+      join125(globalRoot, "omnius", "dist", "scripts", "transcribe-file.py"),
+      join125(globalRoot, "omnius", "scripts", "transcribe-file.py")
+    ];
+    for (const p2 of candidates2) {
+      if (existsSync110(p2)) return p2;
+    }
+  } catch {
+  }
+  return null;
+}
+async function transcribeFileViaWhisper(filePath, model) {
+  const script = await findTranscribeFileScript();
+  if (!script) return null;
+  const bin = process.platform === "win32" ? "Scripts" : "bin";
+  const exe = process.platform === "win32" ? "python.exe" : "python3";
+  const venvPython2 = join125(homedir39(), ".omnius", "venv", bin, exe);
+  if (!existsSync110(venvPython2)) return null;
+  return new Promise((resolve76) => {
+    const child = spawn29(venvPython2, [script], {
+      stdio: ["pipe", "pipe", "pipe"],
+      env: process.env
+    });
+    let out = "";
+    let err = "";
+    let timer = null;
+    const stop2 = (val) => {
+      if (timer) clearTimeout(timer);
+      try {
+        child.kill("SIGTERM");
+      } catch {
+      }
+      resolve76(val ? parse3(val) : null);
+    };
+    function parse3(raw) {
+      try {
+        const j = JSON.parse(raw);
+        if (j.error) return null;
+        if (typeof j.text !== "string") return null;
+        return {
+          text: j.text.trim(),
+          duration: null,
+          speakers: [],
+          segments: []
+        };
+      } catch {
+        return null;
+      }
+    }
+    child.stdout?.on("data", (d2) => {
+      out += d2.toString("utf-8");
+    });
+    child.stderr?.on("data", (d2) => {
+      err += d2.toString("utf-8");
+    });
+    child.once("error", () => stop2(null));
+    child.once("close", () => {
+      if (out.trim()) resolve76(parse3(out));
+      else {
+        void err;
+        resolve76(null);
+      }
+    });
+    timer = setTimeout(() => stop2(null), 12e4);
+    try {
+      child.stdin?.write(JSON.stringify({ path: filePath, model }) + "\n");
+      child.stdin?.end();
+    } catch {
+      stop2(null);
+    }
+  });
+}
+async function findLiveWhisperScript() {
+  const thisDir = dirname37(fileURLToPath16(import.meta.url));
+  const candidates = [
+    join125(thisDir, "../../../../packages/execution/scripts/live-whisper.py"),
+    join125(thisDir, "../../../packages/execution/scripts/live-whisper.py"),
+    join125(thisDir, "../../execution/scripts/live-whisper.py"),
+    // npm install layout — scripts bundled alongside dist
+    join125(thisDir, "../scripts/live-whisper.py"),
+    join125(thisDir, "../../scripts/live-whisper.py")
+  ];
+  for (const p2 of candidates) {
+    if (existsSync110(p2)) return p2;
+  }
+  try {
+    const globalRoot = (await execFileText4("npm", ["root", "-g"], { timeout: 5e3 })).trim();
+    const candidates2 = [
+      join125(globalRoot, "omnius", "dist", "scripts", "live-whisper.py"),
+      join125(globalRoot, "omnius", "scripts", "live-whisper.py")
+    ];
+    for (const p2 of candidates2) {
+      if (existsSync110(p2)) return p2;
+    }
+  } catch {
+  }
+  const nvmBase = join125(homedir39(), ".nvm", "versions", "node");
+  if (existsSync110(nvmBase)) {
+    try {
+      for (const ver of readdirSync35(nvmBase)) {
+        const p2 = join125(
+          nvmBase,
+          ver,
+          "lib",
+          "node_modules",
+          "omnius",
+          "dist",
+          "scripts",
+          "live-whisper.py"
+        );
+        if (existsSync110(p2)) return p2;
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+async function ensureVenvForTranscribeCli() {
+  const bin = process.platform === "win32" ? "Scripts" : "bin";
+  const exe = process.platform === "win32" ? "python.exe" : "python3";
+  const venvBin = join125(homedir39(), ".omnius", "venv", bin);
+  const venvPython2 = join125(venvBin, exe);
+  if (!existsSync110(venvPython2)) {
+    try {
+      const mod3 = await Promise.resolve().then(() => (init_py_embed(), py_embed_exports));
+      if (typeof mod3.ensureEmbedDeps === "function") mod3.ensureEmbedDeps();
+    } catch {
+    }
+  }
+  if (!existsSync110(venvPython2)) {
+    try {
+      mkdirSync68(join125(homedir39(), ".omnius", "venv"), { recursive: true });
+      await execFileText4("python3", ["-m", "venv", join125(homedir39(), ".omnius", "venv")], { timeout: 6e4 });
+    } catch {
+      return false;
+    }
+  }
+  process.env.TRANSCRIBE_PYTHON = venvPython2;
+  const pathSep2 = process.platform === "win32" ? ";" : ":";
+  const currentPath = process.env.PATH || "";
+  if (!currentPath.split(pathSep2).includes(venvBin)) {
+    process.env.PATH = `${venvBin}${pathSep2}${currentPath}`;
+  }
+  try {
+    await execFileText4(venvPython2, ["-c", "import numpy"], { timeout: 1e4 });
+  } catch {
+    try {
+      await execFileText4(venvPython2, ["-m", "pip", "install", "-U", "pip", "setuptools<81", "wheel", "numpy==1.26.4"], { timeout: 3e5 });
+    } catch {
+      return false;
+    }
+  }
+  try {
+    await execFileText4(venvPython2, ["-c", "import transcribe_cli"], { timeout: 1e4 });
+    return true;
+  } catch {
+  }
+  try {
+    await execFileText4(venvPython2, ["-m", "pip", "install", "-U", "transcribe-cli"], { timeout: 3e5 });
+    await execFileText4(venvPython2, ["-c", "import transcribe_cli"], { timeout: 1e4 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function requireTranscribeCliFrom2(packageDir) {
+  try {
+    const { createRequire: createRequire11 } = await import("node:module");
+    const req3 = createRequire11(import.meta.url);
+    const distPath = join125(packageDir, "dist", "index.js");
+    if (existsSync110(distPath)) return req3(distPath);
+    return req3(packageDir);
+  } catch {
+    return null;
+  }
+}
+async function loadManagedTranscribeCli() {
+  const packageDir = join125(MANAGED_TRANSCRIBE_CLI_DIR2, "node_modules", "transcribe-cli");
+  if (!existsSync110(join125(packageDir, "dist", "index.js"))) return null;
+  return requireTranscribeCliFrom2(packageDir);
+}
+async function ensureManagedTranscribeCliNode() {
+  if (await loadManagedTranscribeCli()) return true;
+  if (_managedTranscribeCliInstallPromise) return _managedTranscribeCliInstallPromise;
+  _managedTranscribeCliInstallPromise = (async () => {
+    try {
+      mkdirSync68(MANAGED_TRANSCRIBE_CLI_DIR2, { recursive: true });
+      if (!existsSync110(join125(MANAGED_TRANSCRIBE_CLI_DIR2, "package.json"))) {
+        writeFileSync57(
+          join125(MANAGED_TRANSCRIBE_CLI_DIR2, "package.json"),
+          JSON.stringify({ private: true, dependencies: {} }, null, 2),
+          "utf8"
+        );
+      }
+      await execFileText4("npm", ["install", "--prefix", MANAGED_TRANSCRIBE_CLI_DIR2, "transcribe-cli@^2.0.1"], {
+        timeout: 18e4
+      });
+      return Boolean(await loadManagedTranscribeCli());
+    } catch {
+      return false;
+    }
+  })();
+  return _managedTranscribeCliInstallPromise;
+}
+function ensureTranscribeCliBackground() {
+  if (_bgInstallPromise) return _bgInstallPromise;
+  _bgInstallPromise = (async () => {
+    const nodeReady = await ensureManagedTranscribeCliNode();
+    const pyReady = await ensureVenvForTranscribeCli();
+    return nodeReady && pyReady;
+  })();
+  return _bgInstallPromise;
+}
+async function waitForTranscribeCli() {
+  if (_bgInstallPromise) {
+    return _bgInstallPromise;
+  }
+  return Boolean(await loadManagedTranscribeCli()) && await ensureVenvForTranscribeCli();
+}
+function getListenEngine(config) {
+  if (!_engine) {
+    _engine = new ListenEngine(config);
+  }
+  return _engine;
+}
+var MANAGED_TRANSCRIBE_CLI_DIR2, AUDIO_EXTENSIONS, VIDEO_EXTENSIONS2, listenLiveState, WhisperFallbackTranscriber, ListenEngine, _bgInstallPromise, _managedTranscribeCliInstallPromise, _engine;
+var init_listen = __esm({
+  "packages/cli/src/tui/listen.ts"() {
+    "use strict";
+    init_typed_node_events();
+    init_async_process();
+    MANAGED_TRANSCRIBE_CLI_DIR2 = join125(homedir39(), ".omnius", "runtimes", "asr", "transcribe-cli-node");
+    AUDIO_EXTENSIONS = /* @__PURE__ */ new Set([
+      ".mp3",
+      ".wav",
+      ".flac",
+      ".aac",
+      ".m4a",
+      ".ogg",
+      ".wma",
+      ".opus"
+    ]);
+    VIDEO_EXTENSIONS2 = /* @__PURE__ */ new Set([
+      ".mp4",
+      ".mkv",
+      ".avi",
+      ".mov",
+      ".webm",
+      ".flv",
+      ".wmv",
+      ".m4v",
+      ".ts"
+    ]);
+    listenLiveState = {
+      phase: "idle",
+      backend: "",
+      model: "",
+      micDevice: "",
+      micLevelDb: null,
+      noiseFloorDb: null,
+      speechActive: false,
+      lastTranscript: "",
+      lastTranscriptAt: 0,
+      lastStatus: "",
+      updatedAt: 0
+    };
+    WhisperFallbackTranscriber = class extends EventEmitter6 {
+      constructor(model, scriptPath2) {
+        super();
+        this.model = model;
+        this.scriptPath = scriptPath2;
+      }
+      model;
+      scriptPath;
+      process = null;
+      _ready = false;
+      get ready() {
+        return this._ready;
+      }
+      async start() {
+        let pyPath = "python3";
+        try {
+          const mod3 = await Promise.resolve().then(() => (init_py_embed(), py_embed_exports));
+          const ensure = mod3.ensureEmbedDeps;
+          const getPy = mod3.getVenvPython;
+          if (typeof ensure === "function") {
+            try {
+              const res = ensure();
+              if (res?.log) this.emit("status", res.log.slice(-500));
+            } catch {
+            }
+          }
+          if (typeof getPy === "function") {
+            pyPath = getPy();
+          }
+        } catch {
+        }
+        updateListenLiveState({
+          phase: "loading-model",
+          backend: "openai-whisper",
+          model: this.model,
+          lastStatus: `loading whisper ${this.model} model...`
+        });
+        this.process = spawn29(
+          pyPath,
+          [
+            this.scriptPath,
+            "--model",
+            this.model,
+            "--chunk-seconds",
+            "3",
+            "--window-seconds",
+            "10"
+          ],
+          {
+            stdio: ["pipe", "pipe", "pipe"],
+            env: { ...process.env }
+          }
+        );
+        return new Promise((resolve76, reject) => {
+          const timeout2 = setTimeout(() => {
+            reject(
+              new Error(
+                "Whisper fallback: model load timeout (5 min). First run downloads the model."
+              )
+            );
+          }, 3e5);
+          const rl = createInterface2({ input: this.process.stdout });
+          onReadlineLine(rl, (line) => {
+            try {
+              const evt = JSON.parse(line);
+              switch (evt.type) {
+                case "status":
+                  updateListenLiveState({ lastStatus: String(evt.message ?? "").slice(0, 160) });
+                  this.emit("status", evt.message);
+                  break;
+                case "ready":
+                  this._ready = true;
+                  clearTimeout(timeout2);
+                  updateListenLiveState({ phase: "ready", lastStatus: "whisper model loaded" });
+                  this.emit("ready");
+                  resolve76();
+                  break;
+                case "transcript":
+                  this.emit("transcript", {
+                    text: evt.text,
+                    isFinal: evt.isFinal ?? false
+                  });
+                  break;
+                case "error":
+                  this.emit("error", new Error(evt.message));
+                  break;
+              }
+            } catch {
+            }
+          });
+          this.process.stderr?.on("data", (data) => {
+            const text2 = data.toString().trim();
+            if (text2) this.emit("status", text2);
+          });
+          onChildError(this.process, (err) => {
+            clearTimeout(timeout2);
+            reject(err);
+          });
+          onChildClose(this.process, (code8) => {
+            if (!this._ready) {
+              clearTimeout(timeout2);
+              reject(
+                new Error(`Whisper worker exited with code ${code8} before ready`)
+              );
+            }
+          });
+        });
+      }
+      /** Write PCM16 audio data to the worker's stdin. */
+      write(chunk) {
+        if (this.process?.stdin?.writable) {
+          this.process.stdin.write(chunk);
+        }
+      }
+      /** Stop the worker. */
+      stop() {
+        if (this.process) {
+          try {
+            this.process.stdin?.end();
+            this.process.kill("SIGTERM");
+          } catch {
+          }
+          this.process = null;
+        }
+        this._ready = false;
+      }
+    };
+    ListenEngine = class extends EventEmitter6 {
+      config;
+      micProcess = null;
+      liveTranscriber = null;
+      // TranscribeLive from transcribe-cli or WhisperFallbackTranscriber
+      active = false;
+      paused = false;
+      // Pause state for voicechat (stops mic but keeps transcriber)
+      silenceTimer = null;
+      countdownInterval = null;
+      lastTranscriptTime = 0;
+      pendingText = "";
+      blinkTimer = null;
+      blinkState = false;
+      transcribeCliAvailable = null;
+      constructor(config) {
+        super();
+        this.config = {
+          model: config?.model ?? "base",
+          mode: config?.mode ?? "confirm",
+          silenceTimeoutMs: config?.silenceTimeoutMs ?? 3e3
+        };
+      }
+      get isActive() {
+        return this.active;
+      }
+      get isBlinking() {
+        return this.active && this.blinkState;
+      }
+      get isPaused() {
+        return this.paused;
+      }
+      get currentModel() {
+        return this.config.model;
+      }
+      get currentMode() {
+        return this.config.mode;
+      }
+      get pendingTranscript() {
+        return this.pendingText;
+      }
+      setModel(model) {
+        this.config.model = model;
+      }
+      setMode(mode) {
+        this.config.mode = mode;
+      }
+      // Mic level metering state (dBFS)
+      micLevelDb = null;
+      micNoiseFloorDb = null;
+      micSpeechActive = false;
+      lastLevelEmit = 0;
+      /**
+       * Spawn the mic capture process and wire PCM piping + level metering.
+       * Shared by start() and resume() so both paths meter identically.
+       */
+      spawnMicProcess(micCmd) {
+        this.micProcess = spawn29(micCmd.cmd, micCmd.args, {
+          stdio: ["pipe", "pipe", "pipe"],
+          env: { ...process.env }
+        });
+        updateListenLiveState({ micDevice: micCmd.device });
+        this.micProcess.stdout?.on("data", (chunk) => {
+          this.meterMicChunk(chunk);
+          if (this.active && !this.paused && this.liveTranscriber) {
+            this.liveTranscriber.write(chunk);
+          }
+        });
+        this.micProcess.stderr?.on("data", () => {
+        });
+        onChildError(this.micProcess, (err) => {
+          this.emit("error", new Error(`Mic capture failed: ${err.message}`));
+          this.stop();
+        });
+        onChildClose(this.micProcess, () => {
+          if (this.active && !this.paused) {
+            this.stop();
+          }
+        });
+      }
+      /**
+       * Compute the PCM16 chunk level (dBFS), track an adaptive noise floor, and
+       * flag speech when the level rises meaningfully above it. Drives the status
+       * bar mic indicator and the /live dashboard ASR line.
+       */
+      meterMicChunk(chunk) {
+        const samples = Math.floor(chunk.length / 2);
+        if (samples <= 0) return;
+        let sumSquares = 0;
+        const stride = samples > 4096 ? 4 : 1;
+        let counted = 0;
+        for (let i2 = 0; i2 + 1 < chunk.length; i2 += 2 * stride) {
+          const v = chunk.readInt16LE(i2) / 32768;
+          sumSquares += v * v;
+          counted++;
+        }
+        if (counted === 0) return;
+        const rms = Math.sqrt(sumSquares / counted);
+        const levelDb = 20 * Math.log10(Math.max(1e-6, rms));
+        this.micLevelDb = this.micLevelDb === null ? levelDb : levelDb > this.micLevelDb ? 0.6 * levelDb + 0.4 * this.micLevelDb : 0.2 * levelDb + 0.8 * this.micLevelDb;
+        if (this.micNoiseFloorDb === null) this.micNoiseFloorDb = levelDb;
+        else if (levelDb < this.micNoiseFloorDb) this.micNoiseFloorDb = 0.3 * levelDb + 0.7 * this.micNoiseFloorDb;
+        else this.micNoiseFloorDb = 0.02 * levelDb + 0.98 * this.micNoiseFloorDb;
+        const floor = this.micNoiseFloorDb;
+        const speech = this.micLevelDb > Math.max(-52, floor + 8);
+        const changed = speech !== this.micSpeechActive;
+        this.micSpeechActive = speech;
+        const now2 = Date.now();
+        if (changed || now2 - this.lastLevelEmit >= 300) {
+          this.lastLevelEmit = now2;
+          updateListenLiveState({
+            micLevelDb: Number(this.micLevelDb.toFixed(1)),
+            noiseFloorDb: Number(floor.toFixed(1)),
+            speechActive: speech
+          });
+          this.emit("level", {
+            levelDb: this.micLevelDb,
+            noiseFloorDb: floor,
+            speechActive: speech
+          });
+        }
+      }
+      /** Check if transcribe-cli is available. */
+      async isAvailable() {
+        if (this.transcribeCliAvailable !== null)
+          return this.transcribeCliAvailable;
+        const tc = await this.loadTranscribeCli() || (await ensureManagedTranscribeCliNode() ? await this.loadTranscribeCli() : null);
+        const transcribeCliReady = Boolean(tc && await ensureVenvForTranscribeCli());
+        const whisperFallbackReady = Boolean(await findLiveWhisperScript());
+        this.transcribeCliAvailable = transcribeCliReady || whisperFallbackReady;
+        return this.transcribeCliAvailable;
+      }
+      /** Load transcribe-cli — bundled as a dependency of omnius. */
+      async loadTranscribeCli() {
+        try {
+          const { createRequire: createRequire11 } = await import("node:module");
+          const req3 = createRequire11(import.meta.url);
+          return req3("transcribe-cli");
+        } catch {
+        }
+        const managed = await loadManagedTranscribeCli();
+        if (managed) return managed;
+        try {
+          const globalRoot = (await execFileText4("npm", ["root", "-g"], { timeout: 5e3 })).trim();
+          const tcPath = join125(globalRoot, "transcribe-cli");
+          if (existsSync110(join125(tcPath, "dist", "index.js"))) {
+            const loaded = await requireTranscribeCliFrom2(tcPath);
+            if (loaded) return loaded;
+          }
+        } catch {
+        }
+        const nvmBase = join125(homedir39(), ".nvm", "versions", "node");
+        if (existsSync110(nvmBase)) {
+          try {
+            const { readdirSync: readdirSync61 } = await import("node:fs");
+            for (const ver of readdirSync61(nvmBase)) {
+              const tcPath = join125(
+                nvmBase,
+                ver,
+                "lib",
+                "node_modules",
+                "transcribe-cli"
+              );
+              if (existsSync110(join125(tcPath, "dist", "index.js"))) {
+                const loaded = await requireTranscribeCliFrom2(tcPath);
+                if (loaded) return loaded;
+              }
+            }
+          } catch {
+          }
+        }
+        return null;
+      }
+      /**
+       * Start listening — captures microphone audio and feeds to TranscribeLive.
+       */
+      async start() {
+        if (this.active) return "Already listening.";
+        updateListenLiveState({
+          phase: "bootstrapping",
+          model: this.config.model,
+          backend: "",
+          lastStatus: "starting ASR backend...",
+          speechActive: false
+        });
+        const micCmd = await findMicCaptureCommand();
+        if (!micCmd) {
+          updateListenLiveState({ phase: "error", lastStatus: "no mic capture tool (arecord/sox/ffmpeg)" });
+          return "No microphone capture tool found. Install arecord (Linux), sox (macOS), or ffmpeg.";
+        }
+        let tc = await this.loadTranscribeCli();
+        if (!tc) {
+          if (_bgInstallPromise) {
+            this.emit("info", "Waiting for transcribe-cli install...");
+            await _bgInstallPromise;
+            this.transcribeCliAvailable = null;
+            tc = await this.loadTranscribeCli();
+          }
+          if (!tc) {
+            try {
+              await ensureManagedTranscribeCliNode();
+              this.transcribeCliAvailable = null;
+              tc = await this.loadTranscribeCli();
+            } catch {
+            }
+          }
+        }
+        let usedFallback = false;
+        let transcribeCliError = null;
+        if (tc) {
+          const TranscribeLive = tc.TranscribeLive;
+          if (TranscribeLive) {
+            let tcUpToDate = false;
+            try {
+              const tcPkgPath = join125(
+                dirname37(__require.resolve?.("transcribe-cli/package.json") || ""),
+                "package.json"
+              );
+              if (existsSync110(tcPkgPath)) {
+                const tcPkg = JSON.parse(
+                  __require("fs").readFileSync(tcPkgPath, "utf8")
+                );
+                tcUpToDate = tcPkg.version && tcPkg.version >= "2.0.1";
+              }
+            } catch {
+              try {
+                const out = await execFileText4("npm", ["list", "-g", "transcribe-cli", "--depth=0", "--json"], {
+                  timeout: 1e4
+                });
+                const parsed = JSON.parse(out);
+                const ver = parsed?.dependencies?.["transcribe-cli"]?.version || "";
+                tcUpToDate = ver >= "2.0.1";
+              } catch {
+              }
+            }
+            if (!tcUpToDate) {
+              try {
+                await ensureManagedTranscribeCliNode();
+                this.transcribeCliAvailable = null;
+                const reloaded = await this.loadTranscribeCli();
+                if (reloaded?.TranscribeLive) {
+                  tc = reloaded;
+                }
+              } catch {
+              }
+            }
+            const venvReady = await ensureVenvForTranscribeCli();
+            if (!venvReady) {
+              transcribeCliError = "venv Python missing numpy (required by transcribe-cli) — using whisper fallback";
+            } else {
+              let caughtUncaught = null;
+              const uncaughtHandler = (err) => {
+                const msg = err?.message || String(err);
+                if (msg.includes("live_worker") || msg.includes("numpy") || msg.includes("transcribe_cli") || msg.includes("ModuleNotFoundError") || msg.includes("Traceback")) {
+                  caughtUncaught = err;
+                } else {
+                  throw err;
+                }
+              };
+              process.on("uncaughtException", uncaughtHandler);
+              try {
+                this.liveTranscriber = new TranscribeLive({
+                  model: this.config.model,
+                  sampleRate: 16e3,
+                  channels: 1,
+                  sampleWidth: 2,
+                  chunkDuration: 3
+                });
+                this.liveTranscriber.on(
+                  "transcript",
+                  (evt) => {
+                    if (!evt.text.trim()) return;
+                    this.lastTranscriptTime = Date.now();
+                    this.pendingText = evt.text.trim();
+                    updateListenLiveState({ lastTranscript: this.pendingText, lastTranscriptAt: this.lastTranscriptTime });
+                    this.emit("transcript", this.pendingText, evt.isFinal);
+                    if (this.config.mode === "auto") this.resetSilenceTimer();
+                  }
+                );
+                this.liveTranscriber.on("error", (err) => {
+                  this.emit("error", err);
+                });
+                await new Promise((resolve76, reject) => {
+                  const timeout2 = setTimeout(
+                    () => reject(new Error("Model load timeout (60s)")),
+                    6e4
+                  );
+                  this.liveTranscriber.on("ready", () => {
+                    clearTimeout(timeout2);
+                    resolve76();
+                  });
+                  this.liveTranscriber.on("error", (err) => {
+                    clearTimeout(timeout2);
+                    reject(err);
+                  });
+                });
+                if (caughtUncaught) {
+                  throw caughtUncaught;
+                }
+              } catch (err) {
+                try {
+                  this.liveTranscriber?.stop();
+                } catch {
+                }
+                this.liveTranscriber = null;
+                transcribeCliError = err instanceof Error ? err.message : String(err);
+              } finally {
+                process.removeListener("uncaughtException", uncaughtHandler);
+              }
+            }
+          }
+        }
+        if (!this.liveTranscriber) {
+          const scriptPath2 = await findLiveWhisperScript();
+          if (!scriptPath2) {
+            const hint = transcribeCliError ? ` transcribe-cli error: ${transcribeCliError}` : "";
+            return `No transcription backend available.${hint} live-whisper.py not found.`;
+          }
+          try {
+            const fallback = new WhisperFallbackTranscriber(
+              this.config.model,
+              scriptPath2
+            );
+            usedFallback = true;
+            fallback.on("status", (msg) => {
+              this.emit("info", msg);
+            });
+            await fallback.start();
+            fallback.on("transcript", (evt) => {
+              if (!evt.text.trim()) return;
+              this.lastTranscriptTime = Date.now();
+              this.pendingText = evt.text.trim();
+              updateListenLiveState({ lastTranscript: this.pendingText, lastTranscriptAt: this.lastTranscriptTime });
+              this.emit("transcript", this.pendingText, evt.isFinal);
+              if (this.config.mode === "auto") this.resetSilenceTimer();
+            });
+            fallback.on("error", (err) => {
+              this.emit("error", err);
+            });
+            this.liveTranscriber = fallback;
+          } catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            const tcHint = transcribeCliError ? `
+transcribe-cli error: ${transcribeCliError}` : "";
+            updateListenLiveState({ phase: "error", lastStatus: msg.slice(0, 160) });
+            return `Failed to start live transcription: ${msg}${tcHint}`;
+          }
+        }
+        this.spawnMicProcess(micCmd);
+        this.active = true;
+        this.blinkState = true;
+        this.blinkTimer = setInterval(() => {
+          this.blinkState = !this.blinkState;
+          this.emit("recording", this.blinkState);
+        }, 500);
+        this.lastTranscriptTime = Date.now();
+        this.emit("started");
+        this.emit("recording", true);
+        const modeDesc = this.config.mode === "auto" ? `auto (${this.config.silenceTimeoutMs / 1e3}s timeout)` : "confirm (press Enter to submit)";
+        const backend = usedFallback ? "openai-whisper" : "transcribe-cli";
+        updateListenLiveState({
+          phase: "listening",
+          backend,
+          model: this.config.model,
+          lastStatus: `listening (${modeDesc})`
+        });
+        return `Listening with ${this.config.model} model via ${backend} (${modeDesc})`;
+      }
+      /**
+       * Stop listening — cleanup mic, transcriber, timers.
+       */
+      async stop() {
+        if (!this.active) return "Not listening.";
+        this.active = false;
+        this.blinkState = false;
+        updateListenLiveState({ phase: "idle", speechActive: false, micLevelDb: null, lastStatus: "stopped" });
+        if (this.blinkTimer) {
+          clearInterval(this.blinkTimer);
+          this.blinkTimer = null;
+        }
+        if (this.silenceTimer) {
+          clearTimeout(this.silenceTimer);
+          this.silenceTimer = null;
+        }
+        if (this.countdownInterval) {
+          clearInterval(this.countdownInterval);
+          this.countdownInterval = null;
+        }
+        if (this.micProcess) {
+          try {
+            this.micProcess.kill("SIGTERM");
+          } catch {
+          }
+          this.micProcess = null;
+        }
+        if (this.liveTranscriber) {
+          try {
+            this.liveTranscriber.stop();
+          } catch {
+          }
+          this.liveTranscriber = null;
+        }
+        this.emit("recording", false);
+        this.emit("stopped");
+        const result = this.pendingText;
+        this.pendingText = "";
+        return result || "Stopped listening.";
+      }
+      /**
+       * Accept the current pending transcript (for confirm mode).
+       * Returns the text to inject into the input line.
+       */
+      acceptTranscript() {
+        const text2 = this.pendingText;
+        this.pendingText = "";
+        return text2;
+      }
+      /**
+       * Pause microphone capture (for voicechat during TTS output).
+       * Keeps transcriber alive but stops feeding it audio.
+       */
+      pause() {
+        if (!this.active || this.paused) return;
+        this.paused = true;
+        if (this.blinkTimer) {
+          clearInterval(this.blinkTimer);
+          this.blinkTimer = null;
+        }
+        this.blinkState = false;
+        if (this.micProcess) {
+          try {
+            this.micProcess.kill("SIGTERM");
+          } catch {
+          }
+          this.micProcess = null;
+        }
+        updateListenLiveState({ phase: "paused", speechActive: false, lastStatus: "mic paused (TTS speaking)" });
+        this.emit("paused");
+        this.emit("recording", false);
+      }
+      /**
+       * Resume microphone capture after pause.
+       */
+      async resume() {
+        if (!this.active || !this.paused) return "Not paused.";
+        this.paused = false;
+        const micCmd = await findMicCaptureCommand();
+        if (!micCmd) {
+          return "No microphone capture tool found.";
+        }
+        this.spawnMicProcess(micCmd);
+        this.blinkState = true;
+        this.blinkTimer = setInterval(() => {
+          this.blinkState = !this.blinkState;
+          this.emit("recording", this.blinkState);
+        }, 500);
+        updateListenLiveState({ phase: "listening", lastStatus: "listening" });
+        this.emit("resumed");
+        this.emit("recording", true);
+        return "Resumed listening.";
+      }
+      /**
+       * Create a standalone transcriber for call sessions.
+       * No microphone capture — just an ASR engine you feed PCM chunks to.
+       * Returns an EventEmitter with .write(pcm: Buffer) and 'transcript' events.
+       * Caller is responsible for calling .stop() when done.
+       */
+      async createCallTranscriber() {
+        let tc = await this.loadTranscribeCli();
+        if (!tc && _bgInstallPromise) {
+          await _bgInstallPromise;
+          this.transcribeCliAvailable = null;
+          tc = await this.loadTranscribeCli();
+        }
+        if (!tc) {
+          try {
+            await ensureManagedTranscribeCliNode();
+            this.transcribeCliAvailable = null;
+            tc = await this.loadTranscribeCli();
+          } catch {
+          }
+        }
+        if (tc?.TranscribeLive && await ensureVenvForTranscribeCli()) {
+          try {
+            const transcriber = new tc.TranscribeLive({
+              model: this.config.model,
+              sampleRate: 16e3,
+              channels: 1,
+              sampleWidth: 2,
+              chunkDuration: 3
+            });
+            await new Promise((resolve76, reject) => {
+              const timeout2 = setTimeout(
+                () => reject(new Error("Model load timeout (60s)")),
+                6e4
+              );
+              transcriber.on("ready", () => {
+                clearTimeout(timeout2);
+                resolve76();
+              });
+              transcriber.on("error", (err) => {
+                clearTimeout(timeout2);
+                reject(err);
+              });
+            });
+            return transcriber;
+          } catch {
+          }
+        }
+        const scriptPath2 = await findLiveWhisperScript();
+        if (!scriptPath2) return null;
+        try {
+          const fallback = new WhisperFallbackTranscriber(
+            this.config.model,
+            scriptPath2
+          );
+          await fallback.start();
+          return fallback;
+        } catch {
+          return null;
+        }
+      }
+      /**
+       * Transcribe a file (audio or video) using transcribe-cli.
+       * Returns the transcription result.
+       */
+      async transcribeFile(filePath, outputDir2) {
+        let tc = await this.loadTranscribeCli();
+        if (!tc && _bgInstallPromise) {
+          await _bgInstallPromise;
+          this.transcribeCliAvailable = null;
+          tc = await this.loadTranscribeCli();
+        }
+        if (!tc) {
+          try {
+            await ensureManagedTranscribeCliNode();
+            this.transcribeCliAvailable = null;
+            tc = await this.loadTranscribeCli();
+          } catch {
+          }
+        }
+        await ensureVenvForTranscribeCli();
+        let lastErr = null;
+        if (tc) {
+          try {
+            const result = await tc.transcribe(filePath, {
+              model: this.config.model,
+              format: "json",
+              diarize: false,
+              wordTimestamps: false
+            });
+            if (outputDir2) {
+              const { basename: basename43 } = await import("node:path");
+              const transcriptDir = join125(outputDir2, ".omnius", "transcripts");
+              mkdirSync68(transcriptDir, { recursive: true });
+              const outFile = join125(transcriptDir, `${basename43(filePath)}.txt`);
+              writeFileSync57(outFile, result.text, "utf-8");
+            }
+            return {
+              text: result.text,
+              duration: result.duration,
+              speakers: result.speakers,
+              segments: result.segments
+            };
+          } catch (err) {
+            lastErr = err;
+          }
+        }
+        const fb = await transcribeFileViaWhisper(filePath, this.config.model);
+        if (fb) {
+          if (outputDir2) {
+            const { basename: basename43 } = await import("node:path");
+            const transcriptDir = join125(outputDir2, ".omnius", "transcripts");
+            mkdirSync68(transcriptDir, { recursive: true });
+            const outFile = join125(transcriptDir, `${basename43(filePath)}.txt`);
+            writeFileSync57(outFile, fb.text, "utf-8");
+          }
+          return fb;
+        }
+        if (lastErr) {
+          this.emit(
+            "error",
+            lastErr instanceof Error ? lastErr : new Error(String(lastErr))
+          );
+        }
+        return null;
+      }
+      // -------------------------------------------------------------------------
+      // Auto-mode silence detection
+      // -------------------------------------------------------------------------
+      resetSilenceTimer() {
+        if (this.silenceTimer) clearTimeout(this.silenceTimer);
+        if (this.countdownInterval) clearInterval(this.countdownInterval);
+        const timeoutMs = this.config.silenceTimeoutMs;
+        const startTime = Date.now();
+        this.countdownInterval = setInterval(() => {
+          const elapsed = Date.now() - startTime;
+          const remaining = Math.max(0, Math.ceil((timeoutMs - elapsed) / 1e3));
+          this.emit("countdown", remaining);
+          if (remaining <= 0 && this.countdownInterval) {
+            clearInterval(this.countdownInterval);
+            this.countdownInterval = null;
+          }
+        }, 1e3);
+        this.silenceTimer = setTimeout(() => {
+          if (this.active && this.pendingText) {
+            this.emit("countdown", 0);
+            this.emit("transcript", this.pendingText, true);
+          }
+        }, timeoutMs);
+      }
+    };
+    _bgInstallPromise = null;
+    _managedTranscribeCliInstallPromise = null;
+    _engine = null;
+  }
+});
+
 // packages/cli/src/tui/live-sensors.ts
-import { mkdirSync as mkdirSync67, readFileSync as readFileSync88, writeFileSync as writeFileSync56 } from "node:fs";
-import { basename as basename23, join as join124, relative as relative11 } from "node:path";
+import { mkdirSync as mkdirSync69, readFileSync as readFileSync89, writeFileSync as writeFileSync58 } from "node:fs";
+import { basename as basename23, join as join126, relative as relative11 } from "node:path";
 function liveDir(repoRoot) {
-  return join124(repoRoot, ".omnius", "live");
+  return join126(repoRoot, ".omnius", "live");
 }
 function liveConfigPath(repoRoot) {
-  return join124(liveDir(repoRoot), "config.json");
+  return join126(liveDir(repoRoot), "config.json");
 }
 function liveSnapshotPath(repoRoot) {
-  return join124(liveDir(repoRoot), "latest.json");
+  return join126(liveDir(repoRoot), "latest.json");
 }
 function ensureLiveDir(repoRoot) {
-  mkdirSync67(liveDir(repoRoot), { recursive: true });
+  mkdirSync69(liveDir(repoRoot), { recursive: true });
 }
 function nowIso3(ms) {
   return new Date(ms).toISOString();
@@ -603131,25 +604492,29 @@ function liveDashboardRotationActionFromClick(snapshot, lineText, col) {
 }
 function pushDashboardWrapped(lines, value2, width) {
   const contentWidth = Math.max(10, width - 2);
-  const words = stripDashboardAnsi(value2).replace(/\s+/g, " ").trim().split(" ").filter(Boolean);
+  const normalized = stripDashboardAnsi(value2).replace(/\s+/g, " ").trimEnd();
+  const leading = normalized.match(/^ */)?.[0] ?? "";
+  const words = normalized.slice(leading.length).trimStart().split(" ").filter(Boolean);
   if (words.length === 0) {
     lines.push(`│${" ".repeat(contentWidth)}│`);
     return;
   }
-  let current = "";
+  let current = leading;
   for (const word2 of words) {
-    if (!current) {
-      current = word2.length > contentWidth ? word2.slice(0, contentWidth) : word2;
+    if (current === leading) {
+      const available = Math.max(1, contentWidth - leading.length);
+      current = `${leading}${word2.length > available ? word2.slice(0, available) : 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;
+      const available = Math.max(1, contentWidth - leading.length);
+      current = `${leading}${word2.length > available ? word2.slice(0, available) : word2}`;
     }
   }
-  if (current) lines.push(`│${truncateCell(` ${current}`, contentWidth)}│`);
+  if (current.trim()) lines.push(`│${truncateCell(` ${current}`, contentWidth)}│`);
 }
 function isAudioFailureText(value2) {
   const text2 = String(value2 ?? "").trim();
@@ -603159,6 +604524,9 @@ function isAudioFailureText(value2) {
 function sanitizeLiveAudioError(value2) {
   const text2 = String(value2 ?? "").trim();
   if (!text2) return "";
+  if (/No live input signal detected after probing \d+ audio source/i.test(text2)) {
+    return "No clear live input signal on selected audio input.";
+  }
   if (/transcribe-cli module:\s*No module named ['"]?transcribe_cli/i.test(text2) || /No module named ['"]?transcribe_cli/i.test(text2)) {
     const parts = text2.split(/\s*\|\s*/g).map((part) => part.trim()).filter((part) => part && !/transcribe-cli module:\s*No module named ['"]?transcribe_cli/i.test(part) && !/No module named ['"]?transcribe_cli/i.test(part));
     const preserved = parts.join(" | ").trim();
@@ -603168,7 +604536,7 @@ function sanitizeLiveAudioError(value2) {
 }
 function readPcm16WavActivity(filePath, bins = 36) {
   try {
-    const buf = readFileSync88(filePath);
+    const buf = readFileSync89(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;
@@ -603541,6 +604909,104 @@ function cameraClassificationsSummary(camera, maxChars = 220) {
   });
   return trimOneLine(items.join("; "), maxChars);
 }
+function cameraClassPriority(kind) {
+  if (kind === "face" || kind === "identity") return 0;
+  if (kind === "segment") return 1;
+  if (kind === "object") return 2;
+  if (kind === "track") return 3;
+  if (kind === "clip") return 4;
+  return 5;
+}
+function groupedDashboardClassifications(camera, kinds) {
+  const wanted = new Set(kinds);
+  const grouped = /* @__PURE__ */ new Map();
+  for (const item of camera.classifications ?? []) {
+    if (!wanted.has(item.kind)) continue;
+    const label = trimOneLine(item.label || item.kind, 64) || item.kind;
+    const key = `${item.kind}:${label.toLowerCase()}`;
+    const existing = grouped.get(key);
+    const count = Math.max(1, item.count);
+    if (!existing) {
+      grouped.set(key, {
+        kind: item.kind,
+        label,
+        count,
+        confidence: item.confidence
+      });
+      continue;
+    }
+    existing.count += count;
+    if (item.confidence !== void 0) {
+      existing.confidence = existing.confidence === void 0 ? item.confidence : Math.max(existing.confidence, item.confidence);
+    }
+  }
+  return [...grouped.values()].sort((a2, b) => {
+    const priority = cameraClassPriority(a2.kind) - cameraClassPriority(b.kind);
+    if (priority !== 0) return priority;
+    return (b.confidence ?? 0) - (a2.confidence ?? 0) || b.count - a2.count || a2.label.localeCompare(b.label);
+  });
+}
+function formatDashboardClassList(groups, maxItems = 6) {
+  return groups.slice(0, maxItems).map((group) => {
+    const count = group.count > 1 ? ` x${group.count}` : "";
+    const confidence2 = group.confidence !== void 0 ? ` ${group.confidence.toFixed(2)}` : "";
+    return `${group.label}${count}${confidence2}`;
+  }).join("; ");
+}
+function cleanCameraSummaryForDashboard(value2) {
+  const raw = String(value2 ?? "").trim();
+  if (!raw) return "";
+  const withoutClip = raw.split(/\s+\|\s+clip:/i)[0] ?? raw;
+  return trimOneLine(
+    withoutClip.replace(/\b(?:mask|crop)=\S+/gi, "").replace(/\bbbox=\[[^\]]*\]/gi, "").replace(/\s{2,}/g, " "),
+    220
+  );
+}
+function formatClipDashboardSummary(value2) {
+  const text2 = String(value2 ?? "").trim();
+  if (!text2) return "";
+  const clipText = text2.match(/\bclip:\s*([\s\S]+)$/i)?.[1] ?? text2;
+  const parsed = parseJsonObjectFromText(clipText);
+  if (!parsed) return /\bclip:\s*/i.test(text2) ? `clip: ${trimOneLine(clipText, 120)}` : "";
+  const matches = Array.isArray(parsed["matches"]) ? parsed["matches"] : [];
+  if (matches.length > 0) {
+    const labels = matches.slice(0, 4).map((match) => {
+      const label = trimOneLine(match["label"] ?? match["name"] ?? match["title"] ?? match["id"] ?? "match", 48);
+      const score = boundedConfidence(match["score"] ?? match["similarity"] ?? match["confidence"]);
+      return `${label || "match"}${score !== void 0 ? ` ${score.toFixed(2)}` : ""}`;
+    });
+    return `clip: ${labels.join("; ")}`;
+  }
+  const recognized = Math.max(0, Number(parsed["recognized_count"] ?? 0));
+  const extra = parsed["extra_labels"];
+  if (Array.isArray(extra) && extra.length > 0) {
+    return `clip: extra labels ${extra.slice(0, 4).map((entry) => trimOneLine(entry, 36)).join("; ")}`;
+  }
+  if (typeof extra === "string" && extra.trim()) return `clip: ${trimOneLine(extra, 120)}`;
+  return recognized > 0 ? `clip: ${recognized} recognized match(es)` : "clip: no visual-memory matches";
+}
+function formatAudioAnalysisDashboardSummary(value2) {
+  const text2 = String(value2 ?? "").trim();
+  if (!text2) return "";
+  const parsed = parseJsonObjectFromText(text2);
+  const classifications = Array.isArray(parsed?.["classifications"]) ? parsed["classifications"] : [];
+  if (classifications.length > 0) {
+    return `sound classes: ${classifications.slice(0, 4).map((entry) => {
+      const label = trimOneLine(entry["class"] ?? entry["label"] ?? entry["name"] ?? "sound", 44);
+      const score = boundedConfidence(entry["score"] ?? entry["confidence"]);
+      return `${label || "sound"}${score !== void 0 ? ` ${score.toFixed(2)}` : ""}`;
+    }).join("; ")}`;
+  }
+  return `sound: ${trimOneLine(text2.replace(/\{[\s\S]*$/, ""), 140) || trimOneLine(text2, 140)}`;
+}
+function formatCameraRotationDashboard(camera) {
+  const orientation = camera.orientation;
+  const rotation = orientation?.rotation ?? camera.rotation ?? 0;
+  const base3 = formatCameraRotation(rotation);
+  if (!orientation) return base3;
+  const confidence2 = orientation.confidence !== void 0 ? ` ${orientation.confidence.toFixed(2)}` : "";
+  return `${base3} (${orientation.source}${confidence2})`;
+}
 function cameraPaneBadge(camera) {
   const classifications = camera.classifications ?? [];
   const faceCount = classifications.filter((item) => item.kind === "face" || item.kind === "identity").reduce((sum, item) => sum + Math.max(1, item.count), 0);
@@ -603559,7 +605025,44 @@ function cameraPaneBadge(camera) {
 }
 function cameraSnapshotSummary(camera) {
   if (camera.error) return `error: ${trimOneLine(camera.error, 160)}`;
-  return camera.summary || (camera.classifications?.length ? `classifications: ${cameraClassificationsSummary(camera)}` : "") || summarizeInference(camera.inference);
+  return cleanCameraSummaryForDashboard(camera.summary) || (camera.classifications?.length ? `classifications: ${cameraClassificationsSummary(camera)}` : "") || summarizeInference(camera.inference);
+}
+function cameraDashboardObservationLines(camera, now2, isLast) {
+  const age = Math.max(0, Math.round((now2 - camera.updatedAt) / 1e3));
+  const root = isLast ? "└─" : "├─";
+  const stem = isLast ? "  " : "│ ";
+  const lines = [
+    `${root} ${compactSourceId(camera.source)}  age=${age}s  rotation=${formatCameraRotationDashboard(camera)}`
+  ];
+  if (camera.error) {
+    lines.push(`${stem}└─ error: ${trimOneLine(camera.error, 180)}`);
+    return lines;
+  }
+  const faces = formatDashboardClassList(groupedDashboardClassifications(camera, ["face", "identity"]), 4);
+  const segments = formatDashboardClassList(groupedDashboardClassifications(camera, ["segment"]), 6);
+  const objects = formatDashboardClassList(groupedDashboardClassifications(camera, ["object"]), 6);
+  const tracks = formatDashboardClassList(groupedDashboardClassifications(camera, ["track"]), 4);
+  const triggers = formatDashboardClassList(groupedDashboardClassifications(camera, ["trigger"]), 3);
+  const clip3 = formatClipDashboardSummary(camera.summary) || formatDashboardClassList(groupedDashboardClassifications(camera, ["clip"]), 4);
+  const summary = cameraSnapshotSummary(camera);
+  const includeSummary = summary && !summary.startsWith("classifications:") && !(objects && /^objects:/i.test(summary)) && !(segments && /^segments?:/i.test(summary));
+  const detailLines = [
+    faces ? `faces: ${faces}` : "",
+    segments ? `segments: ${segments}` : "",
+    objects ? `objects: ${objects}` : "",
+    tracks ? `tracks: ${tracks}` : "",
+    triggers ? `triggers: ${triggers}` : "",
+    includeSummary ? summary : "",
+    clip3,
+    camera.framePath ? `frame: ${camera.displayPath || camera.framePath}` : "",
+    camera.orientation?.evidence ? `orientation: ${trimOneLine(camera.orientation.evidence, 120)}` : ""
+  ].filter(Boolean);
+  const last2 = Math.max(0, detailLines.length - 1);
+  detailLines.forEach((detail, index) => {
+    lines.push(`${stem}${index === last2 ? "└─" : "├─"} ${detail}`);
+  });
+  if (detailLines.length === 0) lines.push(`${stem}└─ preview pending`);
+  return lines;
 }
 function formatLiveDashboardFromSnapshot(snapshot, opts = {}) {
   const width = Math.max(60, opts.width ?? 100);
@@ -603599,35 +605102,44 @@ function formatLiveDashboardFromSnapshot(snapshot, opts = {}) {
     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";
-    const classifications = cameraClassificationsSummary(camera);
-    const detailLines = [
-      `${compactSourceId(camera.source)} age=${age}s rotation=${rotation}`,
-      classifications ? `classifications: ${classifications}` : "",
-      cameraSnapshotSummary(camera),
-      camera.framePath ? `frame: ${camera.displayPath || camera.framePath}` : "",
-      camera.orientation?.evidence ? `orientation: ${trimOneLine(camera.orientation.evidence, 120)}` : ""
-    ].filter(Boolean);
-    for (const detail of detailLines.length ? detailLines : ["preview pending"]) {
+  cameras.forEach((camera, index) => {
+    const detailLines = cameraDashboardObservationLines(camera, now2, index === cameras.length - 1);
+    for (const detail of detailLines) {
       pushDashboardWrapped(lines, detail, width);
     }
-  }
+  });
   if (snapshot.audio) {
     lines.push(`├${horizontal}┤`);
+    lines.push(`│${truncateCell(" audio monitor", width - 2)}│`);
     const transcriptFailure = isAudioFailureText(snapshot.audio.transcript) ? snapshot.audio.transcript : "";
     const transcript = transcriptFailure ? "" : snapshot.audio.transcript;
     const audioError = sanitizeLiveAudioError([snapshot.audio.error, transcriptFailure].filter(Boolean).join(" | "));
+    const asr = getListenLiveState();
+    const asrPhaseLabel = {
+      bootstrapping: "bootstrapping deps…",
+      "loading-model": "loading model…",
+      ready: "ready",
+      listening: "listening",
+      paused: "paused (TTS speaking)",
+      error: "error"
+    };
+    const asrMicBits = asr.micLevelDb !== null ? `  mic=${asr.micLevelDb.toFixed(1)}dB${asr.speechActive ? "  ●speech" : ""}` : "";
+    const asrLine = asr.phase !== "idle" ? `│  ├─ whisper: ${[asr.backend, asr.model].filter(Boolean).join(" ") || "starting"} — ${asrPhaseLabel[asr.phase] ?? asr.phase}${asrMicBits}` : "";
+    const asrHeardAge = asr.lastTranscriptAt > 0 ? Math.max(0, Math.round((now2 - asr.lastTranscriptAt) / 1e3)) : null;
+    const asrHeardLine = asr.phase !== "idle" && asr.lastTranscript ? `│  ├─ heard${asrHeardAge !== null ? ` ${asrHeardAge}s ago` : ""}: ${trimOneLine(asr.lastTranscript, 120)}` : "";
+    const asrStatusLine = (asr.phase === "bootstrapping" || asr.phase === "loading-model" || asr.phase === "error") && asr.lastStatus ? `│  ├─ whisper status: ${trimOneLine(asr.lastStatus, 120)}` : "";
     const audioBits = [
-      `audio input=${snapshot.audio.input || snapshot.config.selectedAudioInput || "none"}`,
-      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)}` : ""
+      `├─ input: ${snapshot.audio.input || snapshot.config.selectedAudioInput || "none"}`,
+      asrLine,
+      asrStatusLine,
+      asrHeardLine,
+      snapshot.audio.activity ? `│  ├─ activity: ${snapshot.audio.activity.waveform}  rms=${snapshot.audio.activity.rmsDb.toFixed(1)}dB  active=${Math.round(snapshot.audio.activity.activeRatio * 100)}%` : "",
+      audioError ? `│  ├─ error: ${trimOneLine(audioError, 140)}` : "",
+      transcript ? `│  ├─ asr${snapshot.audio.asrBackend ? ` (${snapshot.audio.asrBackend})` : ""}: ${trimOneLine(transcript, 140)}` : "",
+      snapshot.audio.intake ? `│  ├─ intake: ${snapshot.audio.intake.intendedForAgent ? "for-agent" : "ambient"}  conf=${snapshot.audio.intake.confidence.toFixed(2)}  action=${snapshot.audio.intake.action}` : "",
+      snapshot.audio.analysis ? `│  └─ ${formatAudioAnalysisDashboardSummary(snapshot.audio.analysis)}` : ""
     ].filter(Boolean);
-    for (const item of audioBits.slice(0, 6)) lines.push(`│${truncateCell(` ${item}`, width - 2)}│`);
+    for (const item of audioBits.slice(0, 9)) pushDashboardWrapped(lines, item, width);
   }
   lines.push(`╰${horizontal}╯`);
   return lines;
@@ -603811,15 +605323,23 @@ function parsePactlShortDevices(raw, kind) {
     const parts = line.split("	");
     const name10 = parts[1]?.trim();
     if (!name10) continue;
+    const spec = (parts[3] ?? "").trim();
+    const base3 = kind === "input" ? "Pulse/PipeWire source" : "Pulse/PipeWire sink";
     devices.push({
       id: `pulse:${name10}`,
       label: name10,
-      detail: kind === "input" ? "Pulse/PipeWire source" : "Pulse/PipeWire sink",
+      detail: spec ? `${base3} · ${spec}` : base3,
       source: "pulse"
     });
   }
   return devices;
 }
+function liveDeviceChannels(device) {
+  const match = String(device?.detail ?? "").match(/(\d+)ch\b/);
+  if (!match) return void 0;
+  const channels = Number(match[1]);
+  return Number.isFinite(channels) && channels > 0 ? channels : void 0;
+}
 function parseCameraListJson(raw) {
   try {
     const parsed = JSON.parse(raw);
@@ -603867,7 +605387,7 @@ function parseCameraListText(raw) {
 }
 function loadLiveSensorConfig(repoRoot) {
   try {
-    const parsed = JSON.parse(readFileSync88(liveConfigPath(repoRoot), "utf8"));
+    const parsed = JSON.parse(readFileSync89(liveConfigPath(repoRoot), "utf8"));
     return {
       ...DEFAULT_CONFIG7,
       ...parsed,
@@ -603881,7 +605401,7 @@ function loadLiveSensorConfig(repoRoot) {
 }
 function readLiveSensorSnapshot(repoRoot) {
   try {
-    const parsed = JSON.parse(readFileSync88(liveSnapshotPath(repoRoot), "utf8"));
+    const parsed = JSON.parse(readFileSync89(liveSnapshotPath(repoRoot), "utf8"));
     return parsed?.version === 1 ? parsed : null;
   } catch {
     return null;
@@ -604086,12 +605606,13 @@ async function discoverAudioOutputs() {
   if (devices.length === 0) devices.push({ id: "default", label: "default speaker", detail: "system default", source: "default" });
   return { devices: dedupeDevices(devices), errors };
 }
-async function recordAudioSample(device, durationSec, outputPath3) {
+async function recordAudioSample(device, durationSec, outputPath3, channels) {
   const duration = Math.max(0.2, Math.min(30, Number.isFinite(durationSec) ? durationSec : 1));
   const ffmpegSeconds = duration < 1 ? duration.toFixed(3) : String(Math.ceil(duration));
   const arecordSeconds = String(Math.max(1, Math.ceil(duration)));
   if (device.startsWith("pulse:") && await commandExists2("ffmpeg", 1500)) {
     const source = device.slice("pulse:".length);
+    const channelArgs = (channels ?? 1) > 2 ? ["-af", "pan=mono|c0=c0"] : ["-ac", "1"];
     await execFileText4("ffmpeg", [
       "-hide_banner",
       "-loglevel",
@@ -604102,8 +605623,7 @@ async function recordAudioSample(device, durationSec, outputPath3) {
       source,
       "-t",
       ffmpegSeconds,
-      "-ac",
-      "1",
+      ...channelArgs,
       "-ar",
       "16000",
       "-acodec",
@@ -604212,8 +605732,8 @@ print(json.dumps({"ok": True, "scores": scores}))
     return null;
   }
 }
-async function tryRecordAudioDevice(device, durationSec, outputPath3) {
-  await recordAudioSample(device, durationSec, outputPath3);
+async function tryRecordAudioDevice(device, durationSec, outputPath3, channels) {
+  await recordAudioSample(device, durationSec, outputPath3, channels);
 }
 function hasLiveAudioSignal(activity) {
   if (!activity) return false;
@@ -604247,7 +605767,8 @@ async function recordAudioSampleWithRecovery(preferred, devices, durationSec, ou
   for (const candidate of ordered) {
     attempts.push(candidate);
     try {
-      await tryRecordAudioDevice(candidate, durationSec, outputPath3);
+      const candidateChannels = liveDeviceChannels(devices.find((entry) => entry.id === candidate));
+      await tryRecordAudioDevice(candidate, durationSec, outputPath3, candidateChannels);
       const activity = readPcm16WavActivity(outputPath3);
       const method = audioCaptureMethod(candidate);
       const signalDetected = hasLiveAudioSignal(activity);
@@ -604259,7 +605780,7 @@ async function recordAudioSampleWithRecovery(preferred, devices, durationSec, ou
           device: candidate,
           method,
           activity,
-          bytes: readFileSync88(outputPath3),
+          bytes: readFileSync89(outputPath3),
           errors: [...errors]
         };
       }
@@ -604269,7 +605790,7 @@ async function recordAudioSampleWithRecovery(preferred, devices, durationSec, ou
     }
   }
   if (firstQuietCapture) {
-    writeFileSync56(outputPath3, firstQuietCapture.bytes);
+    writeFileSync58(outputPath3, firstQuietCapture.bytes);
     return {
       ok: true,
       device: firstQuietCapture.device,
@@ -604365,6 +605886,7 @@ var init_live_sensors = __esm({
     init_dist5();
     init_async_process();
     init_image_ascii_preview();
+    init_listen();
     MIN_VIDEO_INTERVAL_MS = 250;
     LOW_LATENCY_VIDEO_INTERVAL_MS = 250;
     MIN_AUDIO_INTERVAL_MS = 1500;
@@ -604977,7 +606499,8 @@ var init_live_sensors = __esm({
           clipSummary = await this.recognizeFrameObjects(preview.framePath, source, sampledAt, { emit: false });
           const current = this.snapshot.cameras?.[source];
           if (current) {
-            current.summary = [current.summary, clipSummary ? `clip: ${trimOneLine(clipSummary, 160)}` : ""].filter(Boolean).join(" | ");
+            const clipLine = formatClipDashboardSummary(clipSummary);
+            current.summary = [cleanCameraSummaryForDashboard(current.summary), clipLine].filter(Boolean).join(" | ");
             current.classifications = mergeCameraClassifications(
               current.classifications,
               classificationsFromClipSummary(clipSummary, sampledAt, preview.framePath)
@@ -605032,7 +606555,7 @@ ${output}`).join("\n\n");
       async previewAudioInput(device = this.config.selectedAudioInput) {
         const input = String(device || "").trim() || this.resolveAudioInput();
         ensureLiveDir(this.repoRoot);
-        const recordingPath = join124(liveDir(this.repoRoot), `audio-preview-${Date.now()}.wav`);
+        const recordingPath = join126(liveDir(this.repoRoot), `audio-preview-${Date.now()}.wav`);
         const capture = await recordAudioSampleWithRecovery(input, this.devices.audioInputs, 0.8, recordingPath, {
           allowFallback: false
         });
@@ -605081,7 +606604,7 @@ ${output}`).join("\n\n");
         const input = this.resolveAudioInput();
         try {
           ensureLiveDir(this.repoRoot);
-          const recordingPath = join124(liveDir(this.repoRoot), "audio-activity.wav");
+          const recordingPath = join126(liveDir(this.repoRoot), "audio-activity.wav");
           const capture = await recordAudioSampleWithRecovery(input, this.devices.audioInputs, AUDIO_ACTIVITY_SAMPLE_SEC, recordingPath, {
             allowFallback: false,
             requireSignal: false
@@ -605124,7 +606647,7 @@ ${output}`).join("\n\n");
           }
           const outputDir2 = liveDir(this.repoRoot);
           ensureLiveDir(this.repoRoot);
-          const recordingPath = join124(outputDir2, `audio-${Date.now()}.wav`);
+          const recordingPath = join126(outputDir2, `audio-${Date.now()}.wav`);
           let transcript = "";
           let asrBackend = "";
           let analysis = "";
@@ -605436,7 +606959,7 @@ reason=${decision2.reason} confidence=${decision2.confidence.toFixed(2)} source=
       }
       persist() {
         ensureLiveDir(this.repoRoot);
-        writeFileSync56(liveConfigPath(this.repoRoot), JSON.stringify(this.config, null, 2), "utf8");
+        writeFileSync58(liveConfigPath(this.repoRoot), JSON.stringify(this.config, null, 2), "utf8");
         this.snapshot = {
           ...this.snapshot,
           version: 1,
@@ -605444,7 +606967,7 @@ reason=${decision2.reason} confidence=${decision2.confidence.toFixed(2)} source=
           config: this.config,
           devices: this.devices
         };
-        writeFileSync56(liveSnapshotPath(this.repoRoot), JSON.stringify(this.snapshot, null, 2), "utf8");
+        writeFileSync58(liveSnapshotPath(this.repoRoot), JSON.stringify(this.snapshot, null, 2), "utf8");
       }
     };
   }
@@ -605590,8 +607113,8 @@ var init_tool_adapter = __esm({
 });
 
 // packages/cli/src/tui/runtime-verification.ts
-import { existsSync as existsSync109, readFileSync as readFileSync89, readdirSync as readdirSync35 } from "node:fs";
-import { dirname as dirname37, extname as extname14, join as join125, relative as relative12, resolve as resolve54 } from "node:path";
+import { existsSync as existsSync111, readFileSync as readFileSync90, readdirSync as readdirSync36 } from "node:fs";
+import { dirname as dirname38, extname as extname14, join as join127, relative as relative12, resolve as resolve54 } from "node:path";
 function safeRelative(root, file) {
   const rel = relative12(root, file);
   return rel && !rel.startsWith("..") ? rel : file;
@@ -605602,16 +607125,16 @@ function collectHtmlFiles(root, maxFiles) {
     if (out.length >= maxFiles || depth > 8) return;
     let entries;
     try {
-      entries = readdirSync35(dir, { withFileTypes: true });
+      entries = readdirSync36(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
       if (out.length >= maxFiles) break;
       if (entry.isDirectory()) {
-        if (!SKIP_DIRS2.has(entry.name)) walk2(join125(dir, entry.name), depth + 1);
+        if (!SKIP_DIRS2.has(entry.name)) walk2(join127(dir, entry.name), depth + 1);
       } else if (entry.isFile() && /\.html?$/i.test(entry.name)) {
-        out.push(join125(dir, entry.name));
+        out.push(join127(dir, entry.name));
       }
     }
   };
@@ -605636,15 +607159,15 @@ function resolveScriptSource(root, htmlFile, src2) {
   const withoutHash = raw.split("#", 1)[0] ?? "";
   const clean5 = withoutHash.split("?", 1)[0] ?? "";
   if (!clean5 || !SCRIPT_EXTS.has(extname14(clean5).toLowerCase())) return null;
-  const abs = clean5.startsWith("/") ? resolve54(root, `.${clean5}`) : resolve54(dirname37(htmlFile), clean5);
+  const abs = clean5.startsWith("/") ? resolve54(root, `.${clean5}`) : resolve54(dirname38(htmlFile), clean5);
   const rel = relative12(root, abs);
   if (rel.startsWith("..") || rel === "") return null;
-  return existsSync109(abs) ? abs : null;
+  return existsSync111(abs) ? abs : null;
 }
 function referencedScriptAssets(root, htmlFile) {
   let html = "";
   try {
-    html = readFileSync89(htmlFile, "utf8");
+    html = readFileSync90(htmlFile, "utf8");
   } catch {
     return [];
   }
@@ -605674,7 +607197,7 @@ async function syntaxCheckJavaScriptModule(source) {
 }
 async function runStaticRuntimeAssetSyntaxCheck(projectRoot, options2 = {}) {
   const root = resolve54(projectRoot);
-  if (!existsSync109(root)) {
+  if (!existsSync111(root)) {
     return { ok: true, checkedAssets: 0, htmlFiles: 0, issues: [], skippedReason: "project root missing" };
   }
   const htmlFiles = collectHtmlFiles(root, options2.maxHtmlFiles ?? 80);
@@ -605687,7 +607210,7 @@ async function runStaticRuntimeAssetSyntaxCheck(projectRoot, options2 = {}) {
       if (issueByAsset.has(assetFile)) continue;
       let source = "";
       try {
-        source = readFileSync89(assetFile, "utf8");
+        source = readFileSync90(assetFile, "utf8");
       } catch {
         continue;
       }
@@ -605760,1194 +607283,6 @@ var init_runtime_verification = __esm({
   }
 });
 
-// packages/cli/src/api/py-embed.ts
-var py_embed_exports = {};
-__export(py_embed_exports, {
-  ensureEmbedDeps: () => ensureEmbedDeps,
-  getVenvPython: () => getVenvPython,
-  runEmbedAudio: () => runEmbedAudio,
-  runEmbedImage: () => runEmbedImage,
-  runEmbedText: () => runEmbedText,
-  runTranscribeFile: () => runTranscribeFile
-});
-import { spawnSync as spawnSync8 } from "node:child_process";
-import { existsSync as existsSync110, mkdirSync as mkdirSync68, writeFileSync as writeFileSync57 } from "node:fs";
-import { join as join126 } from "node:path";
-import { homedir as homedir38 } from "node:os";
-function getVenvDir() {
-  return join126(homedir38(), ".omnius", "venv");
-}
-function getVenvPython() {
-  const base3 = getVenvDir();
-  const bin = process.platform === "win32" ? "Scripts" : "bin";
-  const exe = process.platform === "win32" ? "python.exe" : "python3";
-  return join126(base3, bin, exe);
-}
-function ensureEmbedDeps() {
-  const venv = getVenvDir();
-  let log22 = "";
-  try {
-    mkdirSync68(venv, { recursive: true });
-  } catch {
-  }
-  if (!existsSync110(getVenvPython())) {
-    const mk = spawnSync8("python3", ["-m", "venv", venv], { encoding: "utf8" });
-    log22 += mk.stdout + mk.stderr;
-  }
-  const pip = process.platform === "win32" ? join126(venv, "Scripts", "pip.exe") : join126(venv, "bin", "pip");
-  const up = spawnSync8(pip, ["install", "--upgrade", "pip", "setuptools", "wheel"], { encoding: "utf8", timeout: 3e5 });
-  log22 += up.stdout + up.stderr;
-  const asrPkgs = [
-    "numpy==1.26.4",
-    "soundfile",
-    "faster-whisper",
-    "openai-whisper",
-    // Embedding helpers used elsewhere (kept lightweight compared to full torch stack)
-    "Pillow"
-  ];
-  const ins = spawnSync8(pip, ["install", "--upgrade", ...asrPkgs], { encoding: "utf8", timeout: 9e5 });
-  log22 += ins.stdout + ins.stderr;
-  let fullOk = true;
-  if (process.env["OMNIUS_INSTALL_FULL_EMBED_DEPS"] === "1") {
-    const fullPkgs = ["torch", "torchaudio", "open_clip_torch", "speechbrain"];
-    const full = spawnSync8(pip, ["install", "--upgrade", ...fullPkgs], { encoding: "utf8", timeout: 18e5 });
-    log22 += full.stdout + full.stderr;
-    fullOk = full.status === 0;
-  }
-  const ok3 = ins.status === 0 && up.status === 0 && fullOk;
-  return { ok: ok3, log: log22 };
-}
-function runEmbedImage(input) {
-  const py = getVenvPython();
-  const script = locateScript("embed-image.py");
-  const p2 = spawnSync8(py, [script], { input: JSON.stringify(input), encoding: "utf8" });
-  try {
-    const out = JSON.parse(p2.stdout || "{}");
-    if (Array.isArray(out.embedding)) return new Float32Array(out.embedding);
-  } catch {
-  }
-  return null;
-}
-function runEmbedAudio(input) {
-  const py = getVenvPython();
-  const script = locateScript("embed-audio.py");
-  const p2 = spawnSync8(py, [script], { input: JSON.stringify(input), encoding: "utf8" });
-  try {
-    const out = JSON.parse(p2.stdout || "{}");
-    if (Array.isArray(out.embedding)) return new Float32Array(out.embedding);
-  } catch {
-  }
-  return null;
-}
-function runEmbedText(text2) {
-  const py = getVenvPython();
-  const script = locateScript("embed-text.py");
-  const p2 = spawnSync8(py, [script], { input: JSON.stringify({ text: text2 }), encoding: "utf8" });
-  try {
-    const out = JSON.parse(p2.stdout || "{}");
-    if (Array.isArray(out.embedding)) return new Float32Array(out.embedding);
-  } catch {
-  }
-  return null;
-}
-function runTranscribeFile(input) {
-  const py = getVenvPython();
-  const script = locateScript("transcribe-file.py");
-  const p2 = spawnSync8(py, [script], { input: JSON.stringify(input), encoding: "utf8", timeout: 6e5 });
-  try {
-    const out = JSON.parse(p2.stdout || "{}");
-    if (typeof out.text === "string") return out.text;
-  } catch {
-  }
-  return null;
-}
-function locateScript(name10) {
-  const candidates = [
-    join126(process.cwd(), "dist", "scripts", name10),
-    join126(process.cwd(), name10),
-    join126(process.cwd(), "scripts", name10)
-  ];
-  for (const c9 of candidates) if (existsSync110(c9)) return c9;
-  const fallback = join126(process.cwd(), name10);
-  try {
-    writeFileSync57(fallback, 'print("missing script")\n');
-  } catch {
-  }
-  return fallback;
-}
-var init_py_embed = __esm({
-  "packages/cli/src/api/py-embed.ts"() {
-    "use strict";
-  }
-});
-
-// packages/cli/src/tui/listen.ts
-var listen_exports = {};
-__export(listen_exports, {
-  ListenEngine: () => ListenEngine,
-  ensureTranscribeCliBackground: () => ensureTranscribeCliBackground,
-  getListenEngine: () => getListenEngine,
-  isAudioPath: () => isAudioPath,
-  isTranscribablePath: () => isTranscribablePath,
-  isVideoPath: () => isVideoPath,
-  transcribeFileViaWhisper: () => transcribeFileViaWhisper,
-  waitForTranscribeCli: () => waitForTranscribeCli
-});
-import { spawn as spawn29 } from "node:child_process";
-import {
-  existsSync as existsSync111,
-  mkdirSync as mkdirSync69,
-  writeFileSync as writeFileSync58,
-  readdirSync as readdirSync36
-} from "node:fs";
-import { join as join127, dirname as dirname38 } from "node:path";
-import { homedir as homedir39 } from "node:os";
-import { fileURLToPath as fileURLToPath16 } from "node:url";
-import { EventEmitter as EventEmitter6 } from "node:events";
-import { createInterface as createInterface2 } from "node:readline";
-function isAudioPath(path12) {
-  const ext = path12.toLowerCase().split(".").pop();
-  return ext ? AUDIO_EXTENSIONS.has(`.${ext}`) : false;
-}
-function isVideoPath(path12) {
-  const ext = path12.toLowerCase().split(".").pop();
-  return ext ? VIDEO_EXTENSIONS2.has(`.${ext}`) : false;
-}
-function isTranscribablePath(path12) {
-  return isAudioPath(path12) || isVideoPath(path12);
-}
-async function findMicCaptureCommand() {
-  const platform7 = process.platform;
-  if (platform7 === "linux") {
-    if (await commandExists2("arecord")) {
-      return {
-        cmd: "arecord",
-        args: [
-          "-f",
-          "S16_LE",
-          "-r",
-          "16000",
-          "-c",
-          "1",
-          "-t",
-          "raw",
-          "-q",
-          "-"
-        ]
-      };
-    }
-  }
-  if (platform7 === "darwin") {
-    if (await commandExists2("sox")) {
-      return {
-        cmd: "sox",
-        args: [
-          "-d",
-          "-t",
-          "raw",
-          "-r",
-          "16000",
-          "-c",
-          "1",
-          "-b",
-          "16",
-          "-e",
-          "signed-integer",
-          "-"
-        ]
-      };
-    }
-  }
-  if (await commandExists2("ffmpeg")) {
-    if (platform7 === "linux") {
-      return {
-        cmd: "ffmpeg",
-        args: [
-          "-f",
-          "pulse",
-          "-i",
-          "default",
-          "-ar",
-          "16000",
-          "-ac",
-          "1",
-          "-f",
-          "s16le",
-          "-loglevel",
-          "quiet",
-          "pipe:1"
-        ]
-      };
-    } else if (platform7 === "darwin") {
-      return {
-        cmd: "ffmpeg",
-        args: [
-          "-f",
-          "avfoundation",
-          "-i",
-          ":0",
-          "-ar",
-          "16000",
-          "-ac",
-          "1",
-          "-f",
-          "s16le",
-          "-loglevel",
-          "quiet",
-          "pipe:1"
-        ]
-      };
-    }
-  }
-  return null;
-}
-async function findTranscribeFileScript() {
-  const thisDir = dirname38(fileURLToPath16(import.meta.url));
-  const candidates = [
-    join127(thisDir, "../../../../packages/execution/scripts/transcribe-file.py"),
-    join127(thisDir, "../../../packages/execution/scripts/transcribe-file.py"),
-    join127(thisDir, "../../execution/scripts/transcribe-file.py"),
-    join127(thisDir, "../scripts/transcribe-file.py"),
-    join127(thisDir, "../../scripts/transcribe-file.py")
-  ];
-  for (const p2 of candidates) {
-    if (existsSync111(p2)) return p2;
-  }
-  try {
-    const globalRoot = (await execFileText4("npm", ["root", "-g"], { timeout: 5e3 })).trim();
-    const candidates2 = [
-      join127(globalRoot, "omnius", "dist", "scripts", "transcribe-file.py"),
-      join127(globalRoot, "omnius", "scripts", "transcribe-file.py")
-    ];
-    for (const p2 of candidates2) {
-      if (existsSync111(p2)) return p2;
-    }
-  } catch {
-  }
-  return null;
-}
-async function transcribeFileViaWhisper(filePath, model) {
-  const script = await findTranscribeFileScript();
-  if (!script) return null;
-  const bin = process.platform === "win32" ? "Scripts" : "bin";
-  const exe = process.platform === "win32" ? "python.exe" : "python3";
-  const venvPython2 = join127(homedir39(), ".omnius", "venv", bin, exe);
-  if (!existsSync111(venvPython2)) return null;
-  return new Promise((resolve76) => {
-    const child = spawn29(venvPython2, [script], {
-      stdio: ["pipe", "pipe", "pipe"],
-      env: process.env
-    });
-    let out = "";
-    let err = "";
-    let timer = null;
-    const stop2 = (val) => {
-      if (timer) clearTimeout(timer);
-      try {
-        child.kill("SIGTERM");
-      } catch {
-      }
-      resolve76(val ? parse3(val) : null);
-    };
-    function parse3(raw) {
-      try {
-        const j = JSON.parse(raw);
-        if (j.error) return null;
-        if (typeof j.text !== "string") return null;
-        return {
-          text: j.text.trim(),
-          duration: null,
-          speakers: [],
-          segments: []
-        };
-      } catch {
-        return null;
-      }
-    }
-    child.stdout?.on("data", (d2) => {
-      out += d2.toString("utf-8");
-    });
-    child.stderr?.on("data", (d2) => {
-      err += d2.toString("utf-8");
-    });
-    child.once("error", () => stop2(null));
-    child.once("close", () => {
-      if (out.trim()) resolve76(parse3(out));
-      else {
-        void err;
-        resolve76(null);
-      }
-    });
-    timer = setTimeout(() => stop2(null), 12e4);
-    try {
-      child.stdin?.write(JSON.stringify({ path: filePath, model }) + "\n");
-      child.stdin?.end();
-    } catch {
-      stop2(null);
-    }
-  });
-}
-async function findLiveWhisperScript() {
-  const thisDir = dirname38(fileURLToPath16(import.meta.url));
-  const candidates = [
-    join127(thisDir, "../../../../packages/execution/scripts/live-whisper.py"),
-    join127(thisDir, "../../../packages/execution/scripts/live-whisper.py"),
-    join127(thisDir, "../../execution/scripts/live-whisper.py"),
-    // npm install layout — scripts bundled alongside dist
-    join127(thisDir, "../scripts/live-whisper.py"),
-    join127(thisDir, "../../scripts/live-whisper.py")
-  ];
-  for (const p2 of candidates) {
-    if (existsSync111(p2)) return p2;
-  }
-  try {
-    const globalRoot = (await execFileText4("npm", ["root", "-g"], { timeout: 5e3 })).trim();
-    const candidates2 = [
-      join127(globalRoot, "omnius", "dist", "scripts", "live-whisper.py"),
-      join127(globalRoot, "omnius", "scripts", "live-whisper.py")
-    ];
-    for (const p2 of candidates2) {
-      if (existsSync111(p2)) return p2;
-    }
-  } catch {
-  }
-  const nvmBase = join127(homedir39(), ".nvm", "versions", "node");
-  if (existsSync111(nvmBase)) {
-    try {
-      for (const ver of readdirSync36(nvmBase)) {
-        const p2 = join127(
-          nvmBase,
-          ver,
-          "lib",
-          "node_modules",
-          "omnius",
-          "dist",
-          "scripts",
-          "live-whisper.py"
-        );
-        if (existsSync111(p2)) return p2;
-      }
-    } catch {
-    }
-  }
-  return null;
-}
-async function ensureVenvForTranscribeCli() {
-  const bin = process.platform === "win32" ? "Scripts" : "bin";
-  const exe = process.platform === "win32" ? "python.exe" : "python3";
-  const venvBin = join127(homedir39(), ".omnius", "venv", bin);
-  const venvPython2 = join127(venvBin, exe);
-  if (!existsSync111(venvPython2)) {
-    try {
-      const mod3 = await Promise.resolve().then(() => (init_py_embed(), py_embed_exports));
-      if (typeof mod3.ensureEmbedDeps === "function") mod3.ensureEmbedDeps();
-    } catch {
-    }
-  }
-  if (!existsSync111(venvPython2)) {
-    try {
-      mkdirSync69(join127(homedir39(), ".omnius", "venv"), { recursive: true });
-      await execFileText4("python3", ["-m", "venv", join127(homedir39(), ".omnius", "venv")], { timeout: 6e4 });
-    } catch {
-      return false;
-    }
-  }
-  process.env.TRANSCRIBE_PYTHON = venvPython2;
-  const pathSep2 = process.platform === "win32" ? ";" : ":";
-  const currentPath = process.env.PATH || "";
-  if (!currentPath.split(pathSep2).includes(venvBin)) {
-    process.env.PATH = `${venvBin}${pathSep2}${currentPath}`;
-  }
-  try {
-    await execFileText4(venvPython2, ["-c", "import numpy"], { timeout: 1e4 });
-  } catch {
-    try {
-      await execFileText4(venvPython2, ["-m", "pip", "install", "-U", "pip", "setuptools", "wheel", "numpy==1.26.4"], { timeout: 3e5 });
-    } catch {
-      return false;
-    }
-  }
-  try {
-    await execFileText4(venvPython2, ["-c", "import transcribe_cli"], { timeout: 1e4 });
-    return true;
-  } catch {
-  }
-  try {
-    await execFileText4(venvPython2, ["-m", "pip", "install", "-U", "transcribe-cli"], { timeout: 3e5 });
-    await execFileText4(venvPython2, ["-c", "import transcribe_cli"], { timeout: 1e4 });
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function requireTranscribeCliFrom2(packageDir) {
-  try {
-    const { createRequire: createRequire11 } = await import("node:module");
-    const req3 = createRequire11(import.meta.url);
-    const distPath = join127(packageDir, "dist", "index.js");
-    if (existsSync111(distPath)) return req3(distPath);
-    return req3(packageDir);
-  } catch {
-    return null;
-  }
-}
-async function loadManagedTranscribeCli() {
-  const packageDir = join127(MANAGED_TRANSCRIBE_CLI_DIR2, "node_modules", "transcribe-cli");
-  if (!existsSync111(join127(packageDir, "dist", "index.js"))) return null;
-  return requireTranscribeCliFrom2(packageDir);
-}
-async function ensureManagedTranscribeCliNode() {
-  if (await loadManagedTranscribeCli()) return true;
-  if (_managedTranscribeCliInstallPromise) return _managedTranscribeCliInstallPromise;
-  _managedTranscribeCliInstallPromise = (async () => {
-    try {
-      mkdirSync69(MANAGED_TRANSCRIBE_CLI_DIR2, { recursive: true });
-      if (!existsSync111(join127(MANAGED_TRANSCRIBE_CLI_DIR2, "package.json"))) {
-        writeFileSync58(
-          join127(MANAGED_TRANSCRIBE_CLI_DIR2, "package.json"),
-          JSON.stringify({ private: true, dependencies: {} }, null, 2),
-          "utf8"
-        );
-      }
-      await execFileText4("npm", ["install", "--prefix", MANAGED_TRANSCRIBE_CLI_DIR2, "transcribe-cli@^2.0.1"], {
-        timeout: 18e4
-      });
-      return Boolean(await loadManagedTranscribeCli());
-    } catch {
-      return false;
-    }
-  })();
-  return _managedTranscribeCliInstallPromise;
-}
-function ensureTranscribeCliBackground() {
-  if (_bgInstallPromise) return _bgInstallPromise;
-  _bgInstallPromise = (async () => {
-    const nodeReady = await ensureManagedTranscribeCliNode();
-    const pyReady = await ensureVenvForTranscribeCli();
-    return nodeReady && pyReady;
-  })();
-  return _bgInstallPromise;
-}
-async function waitForTranscribeCli() {
-  if (_bgInstallPromise) {
-    return _bgInstallPromise;
-  }
-  return Boolean(await loadManagedTranscribeCli()) && await ensureVenvForTranscribeCli();
-}
-function getListenEngine(config) {
-  if (!_engine) {
-    _engine = new ListenEngine(config);
-  }
-  return _engine;
-}
-var MANAGED_TRANSCRIBE_CLI_DIR2, AUDIO_EXTENSIONS, VIDEO_EXTENSIONS2, WhisperFallbackTranscriber, ListenEngine, _bgInstallPromise, _managedTranscribeCliInstallPromise, _engine;
-var init_listen = __esm({
-  "packages/cli/src/tui/listen.ts"() {
-    "use strict";
-    init_typed_node_events();
-    init_async_process();
-    MANAGED_TRANSCRIBE_CLI_DIR2 = join127(homedir39(), ".omnius", "runtimes", "asr", "transcribe-cli-node");
-    AUDIO_EXTENSIONS = /* @__PURE__ */ new Set([
-      ".mp3",
-      ".wav",
-      ".flac",
-      ".aac",
-      ".m4a",
-      ".ogg",
-      ".wma",
-      ".opus"
-    ]);
-    VIDEO_EXTENSIONS2 = /* @__PURE__ */ new Set([
-      ".mp4",
-      ".mkv",
-      ".avi",
-      ".mov",
-      ".webm",
-      ".flv",
-      ".wmv",
-      ".m4v",
-      ".ts"
-    ]);
-    WhisperFallbackTranscriber = class extends EventEmitter6 {
-      constructor(model, scriptPath2) {
-        super();
-        this.model = model;
-        this.scriptPath = scriptPath2;
-      }
-      model;
-      scriptPath;
-      process = null;
-      _ready = false;
-      get ready() {
-        return this._ready;
-      }
-      async start() {
-        let pyPath = "python3";
-        try {
-          const mod3 = await Promise.resolve().then(() => (init_py_embed(), py_embed_exports));
-          const ensure = mod3.ensureEmbedDeps;
-          const getPy = mod3.getVenvPython;
-          if (typeof ensure === "function") {
-            try {
-              const res = ensure();
-              if (res?.log) this.emit("status", res.log.slice(-500));
-            } catch {
-            }
-          }
-          if (typeof getPy === "function") {
-            pyPath = getPy();
-          }
-        } catch {
-        }
-        this.process = spawn29(
-          pyPath,
-          [
-            this.scriptPath,
-            "--model",
-            this.model,
-            "--chunk-seconds",
-            "3",
-            "--window-seconds",
-            "10"
-          ],
-          {
-            stdio: ["pipe", "pipe", "pipe"],
-            env: { ...process.env }
-          }
-        );
-        return new Promise((resolve76, reject) => {
-          const timeout2 = setTimeout(() => {
-            reject(
-              new Error(
-                "Whisper fallback: model load timeout (5 min). First run downloads the model."
-              )
-            );
-          }, 3e5);
-          const rl = createInterface2({ input: this.process.stdout });
-          onReadlineLine(rl, (line) => {
-            try {
-              const evt = JSON.parse(line);
-              switch (evt.type) {
-                case "status":
-                  this.emit("status", evt.message);
-                  break;
-                case "ready":
-                  this._ready = true;
-                  clearTimeout(timeout2);
-                  this.emit("ready");
-                  resolve76();
-                  break;
-                case "transcript":
-                  this.emit("transcript", {
-                    text: evt.text,
-                    isFinal: evt.isFinal ?? false
-                  });
-                  break;
-                case "error":
-                  this.emit("error", new Error(evt.message));
-                  break;
-              }
-            } catch {
-            }
-          });
-          this.process.stderr?.on("data", (data) => {
-            const text2 = data.toString().trim();
-            if (text2) this.emit("status", text2);
-          });
-          onChildError(this.process, (err) => {
-            clearTimeout(timeout2);
-            reject(err);
-          });
-          onChildClose(this.process, (code8) => {
-            if (!this._ready) {
-              clearTimeout(timeout2);
-              reject(
-                new Error(`Whisper worker exited with code ${code8} before ready`)
-              );
-            }
-          });
-        });
-      }
-      /** Write PCM16 audio data to the worker's stdin. */
-      write(chunk) {
-        if (this.process?.stdin?.writable) {
-          this.process.stdin.write(chunk);
-        }
-      }
-      /** Stop the worker. */
-      stop() {
-        if (this.process) {
-          try {
-            this.process.stdin?.end();
-            this.process.kill("SIGTERM");
-          } catch {
-          }
-          this.process = null;
-        }
-        this._ready = false;
-      }
-    };
-    ListenEngine = class extends EventEmitter6 {
-      config;
-      micProcess = null;
-      liveTranscriber = null;
-      // TranscribeLive from transcribe-cli or WhisperFallbackTranscriber
-      active = false;
-      paused = false;
-      // Pause state for voicechat (stops mic but keeps transcriber)
-      silenceTimer = null;
-      countdownInterval = null;
-      lastTranscriptTime = 0;
-      pendingText = "";
-      blinkTimer = null;
-      blinkState = false;
-      transcribeCliAvailable = null;
-      constructor(config) {
-        super();
-        this.config = {
-          model: config?.model ?? "base",
-          mode: config?.mode ?? "confirm",
-          silenceTimeoutMs: config?.silenceTimeoutMs ?? 3e3
-        };
-      }
-      get isActive() {
-        return this.active;
-      }
-      get isBlinking() {
-        return this.active && this.blinkState;
-      }
-      get isPaused() {
-        return this.paused;
-      }
-      get currentModel() {
-        return this.config.model;
-      }
-      get currentMode() {
-        return this.config.mode;
-      }
-      get pendingTranscript() {
-        return this.pendingText;
-      }
-      setModel(model) {
-        this.config.model = model;
-      }
-      setMode(mode) {
-        this.config.mode = mode;
-      }
-      /** Check if transcribe-cli is available. */
-      async isAvailable() {
-        if (this.transcribeCliAvailable !== null)
-          return this.transcribeCliAvailable;
-        const tc = await this.loadTranscribeCli() || (await ensureManagedTranscribeCliNode() ? await this.loadTranscribeCli() : null);
-        const transcribeCliReady = Boolean(tc && await ensureVenvForTranscribeCli());
-        const whisperFallbackReady = Boolean(await findLiveWhisperScript());
-        this.transcribeCliAvailable = transcribeCliReady || whisperFallbackReady;
-        return this.transcribeCliAvailable;
-      }
-      /** Load transcribe-cli — bundled as a dependency of omnius. */
-      async loadTranscribeCli() {
-        try {
-          const { createRequire: createRequire11 } = await import("node:module");
-          const req3 = createRequire11(import.meta.url);
-          return req3("transcribe-cli");
-        } catch {
-        }
-        const managed = await loadManagedTranscribeCli();
-        if (managed) return managed;
-        try {
-          const globalRoot = (await execFileText4("npm", ["root", "-g"], { timeout: 5e3 })).trim();
-          const tcPath = join127(globalRoot, "transcribe-cli");
-          if (existsSync111(join127(tcPath, "dist", "index.js"))) {
-            const loaded = await requireTranscribeCliFrom2(tcPath);
-            if (loaded) return loaded;
-          }
-        } catch {
-        }
-        const nvmBase = join127(homedir39(), ".nvm", "versions", "node");
-        if (existsSync111(nvmBase)) {
-          try {
-            const { readdirSync: readdirSync61 } = await import("node:fs");
-            for (const ver of readdirSync61(nvmBase)) {
-              const tcPath = join127(
-                nvmBase,
-                ver,
-                "lib",
-                "node_modules",
-                "transcribe-cli"
-              );
-              if (existsSync111(join127(tcPath, "dist", "index.js"))) {
-                const loaded = await requireTranscribeCliFrom2(tcPath);
-                if (loaded) return loaded;
-              }
-            }
-          } catch {
-          }
-        }
-        return null;
-      }
-      /**
-       * Start listening — captures microphone audio and feeds to TranscribeLive.
-       */
-      async start() {
-        if (this.active) return "Already listening.";
-        const micCmd = await findMicCaptureCommand();
-        if (!micCmd) {
-          return "No microphone capture tool found. Install arecord (Linux), sox (macOS), or ffmpeg.";
-        }
-        let tc = await this.loadTranscribeCli();
-        if (!tc) {
-          if (_bgInstallPromise) {
-            this.emit("info", "Waiting for transcribe-cli install...");
-            await _bgInstallPromise;
-            this.transcribeCliAvailable = null;
-            tc = await this.loadTranscribeCli();
-          }
-          if (!tc) {
-            try {
-              await ensureManagedTranscribeCliNode();
-              this.transcribeCliAvailable = null;
-              tc = await this.loadTranscribeCli();
-            } catch {
-            }
-          }
-        }
-        let usedFallback = false;
-        let transcribeCliError = null;
-        if (tc) {
-          const TranscribeLive = tc.TranscribeLive;
-          if (TranscribeLive) {
-            let tcUpToDate = false;
-            try {
-              const tcPkgPath = join127(
-                dirname38(__require.resolve?.("transcribe-cli/package.json") || ""),
-                "package.json"
-              );
-              if (existsSync111(tcPkgPath)) {
-                const tcPkg = JSON.parse(
-                  __require("fs").readFileSync(tcPkgPath, "utf8")
-                );
-                tcUpToDate = tcPkg.version && tcPkg.version >= "2.0.1";
-              }
-            } catch {
-              try {
-                const out = await execFileText4("npm", ["list", "-g", "transcribe-cli", "--depth=0", "--json"], {
-                  timeout: 1e4
-                });
-                const parsed = JSON.parse(out);
-                const ver = parsed?.dependencies?.["transcribe-cli"]?.version || "";
-                tcUpToDate = ver >= "2.0.1";
-              } catch {
-              }
-            }
-            if (!tcUpToDate) {
-              try {
-                await ensureManagedTranscribeCliNode();
-                this.transcribeCliAvailable = null;
-                const reloaded = await this.loadTranscribeCli();
-                if (reloaded?.TranscribeLive) {
-                  tc = reloaded;
-                }
-              } catch {
-              }
-            }
-            const venvReady = await ensureVenvForTranscribeCli();
-            if (!venvReady) {
-              transcribeCliError = "venv Python missing numpy (required by transcribe-cli) — using whisper fallback";
-            } else {
-              let caughtUncaught = null;
-              const uncaughtHandler = (err) => {
-                const msg = err?.message || String(err);
-                if (msg.includes("live_worker") || msg.includes("numpy") || msg.includes("transcribe_cli") || msg.includes("ModuleNotFoundError") || msg.includes("Traceback")) {
-                  caughtUncaught = err;
-                } else {
-                  throw err;
-                }
-              };
-              process.on("uncaughtException", uncaughtHandler);
-              try {
-                this.liveTranscriber = new TranscribeLive({
-                  model: this.config.model,
-                  sampleRate: 16e3,
-                  channels: 1,
-                  sampleWidth: 2,
-                  chunkDuration: 3
-                });
-                this.liveTranscriber.on(
-                  "transcript",
-                  (evt) => {
-                    if (!evt.text.trim()) return;
-                    this.lastTranscriptTime = Date.now();
-                    this.pendingText = evt.text.trim();
-                    this.emit("transcript", this.pendingText, evt.isFinal);
-                    if (this.config.mode === "auto") this.resetSilenceTimer();
-                  }
-                );
-                this.liveTranscriber.on("error", (err) => {
-                  this.emit("error", err);
-                });
-                await new Promise((resolve76, reject) => {
-                  const timeout2 = setTimeout(
-                    () => reject(new Error("Model load timeout (60s)")),
-                    6e4
-                  );
-                  this.liveTranscriber.on("ready", () => {
-                    clearTimeout(timeout2);
-                    resolve76();
-                  });
-                  this.liveTranscriber.on("error", (err) => {
-                    clearTimeout(timeout2);
-                    reject(err);
-                  });
-                });
-                if (caughtUncaught) {
-                  throw caughtUncaught;
-                }
-              } catch (err) {
-                try {
-                  this.liveTranscriber?.stop();
-                } catch {
-                }
-                this.liveTranscriber = null;
-                transcribeCliError = err instanceof Error ? err.message : String(err);
-              } finally {
-                process.removeListener("uncaughtException", uncaughtHandler);
-              }
-            }
-          }
-        }
-        if (!this.liveTranscriber) {
-          const scriptPath2 = await findLiveWhisperScript();
-          if (!scriptPath2) {
-            const hint = transcribeCliError ? ` transcribe-cli error: ${transcribeCliError}` : "";
-            return `No transcription backend available.${hint} live-whisper.py not found.`;
-          }
-          try {
-            const fallback = new WhisperFallbackTranscriber(
-              this.config.model,
-              scriptPath2
-            );
-            usedFallback = true;
-            fallback.on("status", (msg) => {
-              this.emit("info", msg);
-            });
-            await fallback.start();
-            fallback.on("transcript", (evt) => {
-              if (!evt.text.trim()) return;
-              this.lastTranscriptTime = Date.now();
-              this.pendingText = evt.text.trim();
-              this.emit("transcript", this.pendingText, evt.isFinal);
-              if (this.config.mode === "auto") this.resetSilenceTimer();
-            });
-            fallback.on("error", (err) => {
-              this.emit("error", err);
-            });
-            this.liveTranscriber = fallback;
-          } catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            const tcHint = transcribeCliError ? `
-transcribe-cli error: ${transcribeCliError}` : "";
-            return `Failed to start live transcription: ${msg}${tcHint}`;
-          }
-        }
-        this.micProcess = spawn29(micCmd.cmd, micCmd.args, {
-          stdio: ["pipe", "pipe", "pipe"],
-          env: { ...process.env }
-        });
-        this.micProcess.stdout?.on("data", (chunk) => {
-          if (this.active && !this.paused && this.liveTranscriber) {
-            this.liveTranscriber.write(chunk);
-          }
-        });
-        this.micProcess.stderr?.on("data", () => {
-        });
-        onChildError(this.micProcess, (err) => {
-          this.emit("error", new Error(`Mic capture failed: ${err.message}`));
-          this.stop();
-        });
-        onChildClose(this.micProcess, () => {
-          if (this.active) {
-            this.stop();
-          }
-        });
-        this.active = true;
-        this.blinkState = true;
-        this.blinkTimer = setInterval(() => {
-          this.blinkState = !this.blinkState;
-          this.emit("recording", this.blinkState);
-        }, 500);
-        this.lastTranscriptTime = Date.now();
-        this.emit("started");
-        this.emit("recording", true);
-        const modeDesc = this.config.mode === "auto" ? `auto (${this.config.silenceTimeoutMs / 1e3}s timeout)` : "confirm (press Enter to submit)";
-        const backend = usedFallback ? "openai-whisper" : "transcribe-cli";
-        return `Listening with ${this.config.model} model via ${backend} (${modeDesc})`;
-      }
-      /**
-       * Stop listening — cleanup mic, transcriber, timers.
-       */
-      async stop() {
-        if (!this.active) return "Not listening.";
-        this.active = false;
-        this.blinkState = false;
-        if (this.blinkTimer) {
-          clearInterval(this.blinkTimer);
-          this.blinkTimer = null;
-        }
-        if (this.silenceTimer) {
-          clearTimeout(this.silenceTimer);
-          this.silenceTimer = null;
-        }
-        if (this.countdownInterval) {
-          clearInterval(this.countdownInterval);
-          this.countdownInterval = null;
-        }
-        if (this.micProcess) {
-          try {
-            this.micProcess.kill("SIGTERM");
-          } catch {
-          }
-          this.micProcess = null;
-        }
-        if (this.liveTranscriber) {
-          try {
-            this.liveTranscriber.stop();
-          } catch {
-          }
-          this.liveTranscriber = null;
-        }
-        this.emit("recording", false);
-        this.emit("stopped");
-        const result = this.pendingText;
-        this.pendingText = "";
-        return result || "Stopped listening.";
-      }
-      /**
-       * Accept the current pending transcript (for confirm mode).
-       * Returns the text to inject into the input line.
-       */
-      acceptTranscript() {
-        const text2 = this.pendingText;
-        this.pendingText = "";
-        return text2;
-      }
-      /**
-       * Pause microphone capture (for voicechat during TTS output).
-       * Keeps transcriber alive but stops feeding it audio.
-       */
-      pause() {
-        if (!this.active || this.paused) return;
-        this.paused = true;
-        if (this.blinkTimer) {
-          clearInterval(this.blinkTimer);
-          this.blinkTimer = null;
-        }
-        this.blinkState = false;
-        if (this.micProcess) {
-          try {
-            this.micProcess.kill("SIGTERM");
-          } catch {
-          }
-          this.micProcess = null;
-        }
-        this.emit("paused");
-        this.emit("recording", false);
-      }
-      /**
-       * Resume microphone capture after pause.
-       */
-      async resume() {
-        if (!this.active || !this.paused) return "Not paused.";
-        this.paused = false;
-        const micCmd = await findMicCaptureCommand();
-        if (!micCmd) {
-          return "No microphone capture tool found.";
-        }
-        this.micProcess = spawn29(micCmd.cmd, micCmd.args, {
-          stdio: ["pipe", "pipe", "pipe"],
-          env: { ...process.env }
-        });
-        this.micProcess.stdout?.on("data", (chunk) => {
-          if (this.active && !this.paused && this.liveTranscriber) {
-            this.liveTranscriber.write(chunk);
-          }
-        });
-        this.micProcess.stderr?.on("data", () => {
-        });
-        onChildError(this.micProcess, (err) => {
-          this.emit("error", new Error(`Mic capture failed: ${err.message}`));
-          this.stop();
-        });
-        onChildClose(this.micProcess, () => {
-          if (this.active && !this.paused) {
-            this.stop();
-          }
-        });
-        this.blinkState = true;
-        this.blinkTimer = setInterval(() => {
-          this.blinkState = !this.blinkState;
-          this.emit("recording", this.blinkState);
-        }, 500);
-        this.emit("resumed");
-        this.emit("recording", true);
-        return "Resumed listening.";
-      }
-      /**
-       * Create a standalone transcriber for call sessions.
-       * No microphone capture — just an ASR engine you feed PCM chunks to.
-       * Returns an EventEmitter with .write(pcm: Buffer) and 'transcript' events.
-       * Caller is responsible for calling .stop() when done.
-       */
-      async createCallTranscriber() {
-        let tc = await this.loadTranscribeCli();
-        if (!tc && _bgInstallPromise) {
-          await _bgInstallPromise;
-          this.transcribeCliAvailable = null;
-          tc = await this.loadTranscribeCli();
-        }
-        if (!tc) {
-          try {
-            await ensureManagedTranscribeCliNode();
-            this.transcribeCliAvailable = null;
-            tc = await this.loadTranscribeCli();
-          } catch {
-          }
-        }
-        if (tc?.TranscribeLive && await ensureVenvForTranscribeCli()) {
-          try {
-            const transcriber = new tc.TranscribeLive({
-              model: this.config.model,
-              sampleRate: 16e3,
-              channels: 1,
-              sampleWidth: 2,
-              chunkDuration: 3
-            });
-            await new Promise((resolve76, reject) => {
-              const timeout2 = setTimeout(
-                () => reject(new Error("Model load timeout (60s)")),
-                6e4
-              );
-              transcriber.on("ready", () => {
-                clearTimeout(timeout2);
-                resolve76();
-              });
-              transcriber.on("error", (err) => {
-                clearTimeout(timeout2);
-                reject(err);
-              });
-            });
-            return transcriber;
-          } catch {
-          }
-        }
-        const scriptPath2 = await findLiveWhisperScript();
-        if (!scriptPath2) return null;
-        try {
-          const fallback = new WhisperFallbackTranscriber(
-            this.config.model,
-            scriptPath2
-          );
-          await fallback.start();
-          return fallback;
-        } catch {
-          return null;
-        }
-      }
-      /**
-       * Transcribe a file (audio or video) using transcribe-cli.
-       * Returns the transcription result.
-       */
-      async transcribeFile(filePath, outputDir2) {
-        let tc = await this.loadTranscribeCli();
-        if (!tc && _bgInstallPromise) {
-          await _bgInstallPromise;
-          this.transcribeCliAvailable = null;
-          tc = await this.loadTranscribeCli();
-        }
-        if (!tc) {
-          try {
-            await ensureManagedTranscribeCliNode();
-            this.transcribeCliAvailable = null;
-            tc = await this.loadTranscribeCli();
-          } catch {
-          }
-        }
-        await ensureVenvForTranscribeCli();
-        let lastErr = null;
-        if (tc) {
-          try {
-            const result = await tc.transcribe(filePath, {
-              model: this.config.model,
-              format: "json",
-              diarize: false,
-              wordTimestamps: false
-            });
-            if (outputDir2) {
-              const { basename: basename43 } = await import("node:path");
-              const transcriptDir = join127(outputDir2, ".omnius", "transcripts");
-              mkdirSync69(transcriptDir, { recursive: true });
-              const outFile = join127(transcriptDir, `${basename43(filePath)}.txt`);
-              writeFileSync58(outFile, result.text, "utf-8");
-            }
-            return {
-              text: result.text,
-              duration: result.duration,
-              speakers: result.speakers,
-              segments: result.segments
-            };
-          } catch (err) {
-            lastErr = err;
-          }
-        }
-        const fb = await transcribeFileViaWhisper(filePath, this.config.model);
-        if (fb) {
-          if (outputDir2) {
-            const { basename: basename43 } = await import("node:path");
-            const transcriptDir = join127(outputDir2, ".omnius", "transcripts");
-            mkdirSync69(transcriptDir, { recursive: true });
-            const outFile = join127(transcriptDir, `${basename43(filePath)}.txt`);
-            writeFileSync58(outFile, fb.text, "utf-8");
-          }
-          return fb;
-        }
-        if (lastErr) {
-          this.emit(
-            "error",
-            lastErr instanceof Error ? lastErr : new Error(String(lastErr))
-          );
-        }
-        return null;
-      }
-      // -------------------------------------------------------------------------
-      // Auto-mode silence detection
-      // -------------------------------------------------------------------------
-      resetSilenceTimer() {
-        if (this.silenceTimer) clearTimeout(this.silenceTimer);
-        if (this.countdownInterval) clearInterval(this.countdownInterval);
-        const timeoutMs = this.config.silenceTimeoutMs;
-        const startTime = Date.now();
-        this.countdownInterval = setInterval(() => {
-          const elapsed = Date.now() - startTime;
-          const remaining = Math.max(0, Math.ceil((timeoutMs - elapsed) / 1e3));
-          this.emit("countdown", remaining);
-          if (remaining <= 0 && this.countdownInterval) {
-            clearInterval(this.countdownInterval);
-            this.countdownInterval = null;
-          }
-        }, 1e3);
-        this.silenceTimer = setTimeout(() => {
-          if (this.active && this.pendingText) {
-            this.emit("countdown", 0);
-            this.emit("transcript", this.pendingText, true);
-          }
-        }, timeoutMs);
-      }
-    };
-    _bgInstallPromise = null;
-    _managedTranscribeCliInstallPromise = null;
-    _engine = null;
-  }
-});
-
 // node_modules/.pnpm/ws@8.20.1/node_modules/ws/lib/constants.js
 var require_constants11 = __commonJS({
   "node_modules/.pnpm/ws@8.20.1/node_modules/ws/lib/constants.js"(exports, module) {
@@ -625597,6 +625932,10 @@ var init_status_bar = __esm({
       inputStateProvider = null;
       /** Whether microphone is recording (blinking indicator) */
       _recording = false;
+      /** Whether speech is currently detected on the mic (from ListenEngine metering) */
+      _micSpeech = false;
+      /** Current mic input level in dBFS (rounded), null when unknown */
+      _micLevelDb = null;
       /** Countdown seconds for auto-mode silence timeout (0 = not counting down) */
       _countdown = 0;
       _recBlink = true;
@@ -626410,6 +626749,18 @@ var init_status_bar = __esm({
         this._countdown = seconds;
         if (this.active) this.renderFooterPreserveCursor();
       }
+      /**
+       * Update live mic activity: whether speech is currently detected and the
+       * current input level (dBFS). Drives the REC indicator so it reflects real
+       * whisper-bound speech instead of only a blink timer.
+       */
+      setMicActivity(speech, levelDb) {
+        const level = typeof levelDb === "number" && Number.isFinite(levelDb) ? Math.round(levelDb) : null;
+        if (speech === this._micSpeech && level === this._micLevelDb) return;
+        this._micSpeech = speech;
+        this._micLevelDb = level;
+        if (this.active && this._recording) this.renderFooterPreserveCursor();
+      }
       /** Start or stop the braille-dot processing animation on the buffer line. */
       setProcessing(active) {
         if (active === this._processing) return;
@@ -629087,10 +629438,19 @@ ${CONTENT_BG_SEQ}`);
           });
         }
         if (this._recording) {
-          const dot = this._recBlink ? pastel2(210, "●") : " ";
           const countdown = this._countdown > 0 ? c3.dim(` ${_StatusBar.digitBar(this._countdown)}s`) : "";
-          const recStr = dot + pastel2(210, " REC") + countdown;
-          const recW = 1 + 4 + (this._countdown > 0 ? 1 + `${this._countdown}s`.length : 0);
+          const countdownW = this._countdown > 0 ? 1 + `${this._countdown}s`.length : 0;
+          let recStr;
+          let recW;
+          if (this._micSpeech) {
+            recStr = pastel2(210, "● REC") + countdown;
+            recW = 5 + countdownW;
+          } else {
+            const dot = this._recBlink ? pastel2(210, "●") : c3.dim("○");
+            const levelStr = this._micLevelDb !== null ? ` ${this._micLevelDb}dB` : "";
+            recStr = dot + c3.dim(` mic${levelStr}`) + countdown;
+            recW = 1 + 4 + levelStr.length + countdownW;
+          }
           sections.push({
             expanded: recStr,
             compact: recStr,
@@ -696041,6 +696401,19 @@ function repeatingCharPenalty(s2) {
   if (cur > maxRun) maxRun = cur;
   return Math.min(1, Math.max(0, (maxRun - 3) / 10));
 }
+function gibberishTokenPenalty(s2) {
+  const tokens = s2.trim().split(/\s+/).filter(Boolean);
+  if (tokens.length < 2) return 0;
+  let penalty = 0;
+  const unique2 = new Set(tokens.map((t2) => t2.toLowerCase()));
+  const uniqueRatio = unique2.size / tokens.length;
+  if (tokens.length >= 4 && uniqueRatio <= 0.5) {
+    penalty += Math.min(1, (0.5 - uniqueRatio) * 2 + 0.5);
+  }
+  const mixed = tokens.filter((t2) => /^(?=.*[A-Za-z])(?=.*\d)[A-Za-z\d]{3,}$/.test(t2) && /[A-Za-z]\d|\d[A-Za-z]/.test(t2));
+  if (mixed.length / tokens.length >= 0.5) penalty += 0.8;
+  return Math.min(1, penalty);
+}
 function computeSignalFromText(text2, confidence2) {
   const t2 = text2.trim();
   if (!t2) return 0;
@@ -696055,6 +696428,7 @@ function computeSignalFromText(text2, confidence2) {
   else if (wc >= 1 && alpha >= 0.3 && len >= 4) score = 0.35;
   else score = 0.15;
   score -= repeatingCharPenalty(t2) * 0.4;
+  score -= gibberishTokenPenalty(t2) * 0.8;
   if (typeof confidence2 === "number" && !Number.isNaN(confidence2)) {
     score = 0.7 * score + 0.3 * clamp0116(confidence2);
   }
@@ -696063,6 +696437,9 @@ function computeSignalFromText(text2, confidence2) {
 function truncateForLog(s2, n2) {
   return s2.length <= n2 ? s2 : s2.slice(0, n2 - 1) + "…";
 }
+function sanitizeToolName2(name10) {
+  return name10.trim().replace(/[({\[].*$/, "").replace(/[^A-Za-z0-9_-]/g, "");
+}
 function extractToolJson(text2) {
   const lines = text2.split(/\r?\n/);
   for (const line of lines) {
@@ -696071,7 +696448,8 @@ function extractToolJson(text2) {
     try {
       const obj = JSON.parse(t2);
       if (typeof obj.tool === "string") {
-        const name10 = obj.tool;
+        const name10 = sanitizeToolName2(obj.tool);
+        if (!name10) continue;
         const args = obj.args && typeof obj.args === "object" ? obj.args : {};
         return { name: name10, args };
       }
@@ -696089,18 +696467,38 @@ function extractToolJsonLoose(text2) {
     try {
       const obj = JSON.parse(match[0]);
       if (typeof obj.tool === "string") {
-        const args = obj.args && typeof obj.args === "object" ? obj.args : {};
-        return { name: obj.tool, args };
+        const name10 = sanitizeToolName2(obj.tool);
+        if (name10) {
+          const args = obj.args && typeof obj.args === "object" ? obj.args : {};
+          return { name: name10, args };
+        }
       }
     } catch {
     }
   }
+  const nameMatch = stripped.match(/"tool"\s*:\s*"?\s*([A-Za-z0-9_-]+)/);
+  if (nameMatch?.[1]) {
+    const name10 = sanitizeToolName2(nameMatch[1]);
+    if (name10) {
+      let args = {};
+      const argsMatch = stripped.match(/"args"\s*:\s*(\{[\s\S]*?\})/);
+      if (argsMatch?.[1]) {
+        try {
+          const parsed = JSON.parse(argsMatch[1]);
+          if (parsed && typeof parsed === "object") args = parsed;
+        } catch {
+        }
+      }
+      return { name: name10, args };
+    }
+  }
   return null;
 }
 function stripToolJsonLines(text2) {
   const lines = text2.split(/\r?\n/);
   const kept = lines.filter((l2) => {
     const t2 = l2.trim();
+    if (/^\{\s*"?tool"?\s*[:=]/.test(t2)) return false;
     if (!t2.startsWith("{") || !t2.endsWith("}")) return true;
     try {
       const obj = JSON.parse(t2);
@@ -696340,12 +696738,12 @@ Rules:
         this.active = true;
         this.context = [{ role: "system", content: SYSTEM_PROMPT2 }];
         if (this.toolRelay) {
-          this.toolCatalogNote = `Available tools (emit one-line JSON: {"tool":string,"args":object}):
-- voice_env{} → environment facts (cwd, os, cpu, mem)
-- voice_status{} → main-agent status
-- voice_list_files{dir?: string='.'} → list directory (bounded)
-- voice_read_file{path: string, max?: number=2048} → read file snippet
-- voice_to_main{message: string, start?: boolean=true} → relay/start task`;
+          this.toolCatalogNote = `Available tools. To call one, emit exactly one line of valid JSON and nothing else:
+{"tool":"voice_env","args":{}} → environment facts (cwd, os, cpu, mem)
+{"tool":"voice_status","args":{}} → main-agent status
+{"tool":"voice_list_files","args":{"dir":"."}} → list directory (bounded)
+{"tool":"voice_read_file","args":{"path":"<file>","max":2048}} → read file snippet
+{"tool":"voice_to_main","args":{"message":"<task>","start":true}} → relay/start task`;
           this.context.push({ role: "system", content: this.toolCatalogNote });
         }
         this.turnCount = 0;
@@ -696488,7 +696886,7 @@ Rules:
           this.setState("LISTENING");
           return;
         }
-        const score = this.lastSignalScore ?? computeSignalFromText(text2);
+        const score = Math.min(this.lastSignalScore ?? 1, computeSignalFromText(text2));
         if (score < MIN_SIGNAL_SCORE || NOISE_ONLY_RE.test(text2)) {
           if (this.debugSnr) this.onStatus(`Ignoring low-signal utterance (SNR:${score.toFixed(2)}): ${truncateForLog(text2, 48)}`);
           this.emit("snrFiltered", { score, text: text2 });
@@ -735480,6 +735878,9 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
       engine.on("recording", (active) => {
         statusBar.setRecording(active);
       });
+      engine.on("level", (evt) => {
+        statusBar.setMicActivity(evt.speechActive, evt.levelDb);
+      });
       engine.on("countdown", (seconds) => {
         statusBar.setCountdown(seconds);
       });
@@ -735784,6 +736185,12 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
       const { VoiceChatSession: VoiceChatSession2 } = await Promise.resolve().then(() => (init_voicechat(), voicechat_exports));
       const { ListenEngine: ListenEngine2 } = await Promise.resolve().then(() => (init_listen(), listen_exports));
       const listenEng = new ListenEngine2();
+      listenEng.on("recording", (active) => {
+        statusBar.setRecording(active);
+      });
+      listenEng.on("level", (evt) => {
+        statusBar.setMicActivity(evt.speechActive, evt.levelDb);
+      });
       const summaryRunner = {
         injectUserMessage(content) {
           if (activeTask?.runner) {