omnius 1.0.417 → 1.0.419

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,1397 @@ 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}` };
+}
+async function ensureSourceCaptureVolume(source) {
+  try {
+    await execFileText4("pactl", ["set-source-mute", source, "0"], { timeout: 3e3 });
+  } catch {
+  }
+  try {
+    const raw = await execFileText4("pactl", ["get-source-volume", source], { timeout: 3e3 });
+    const percents = [...raw.matchAll(/(\d+)%/g)].map((m2) => Number(m2[1])).filter((n2) => Number.isFinite(n2));
+    const current = percents.length ? Math.max(...percents) : null;
+    if (current !== null && current < 100) {
+      await execFileText4("pactl", ["set-source-volume", source, "100%"], { timeout: 3e3 });
+    }
+  } catch {
+  }
+}
+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")) {
+      await ensureSourceCaptureVolume(resolved.pulseSource);
+      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(-58, floor + 6);
+        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();
@@ -603175,7 +604552,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;
@@ -603214,7 +604591,7 @@ function readPcm16WavActivity(filePath, bins = 36) {
       const abs = Math.abs(sample);
       peak = Math.max(peak, abs);
       sumSquares += sample * sample;
-      if (abs > 0.018) active++;
+      if (abs > 8e-3) active++;
       const b = Math.min(bucketSquares.length - 1, Math.floor(i2 / frames * bucketSquares.length));
       bucketSquares[b] += sample * sample;
       bucketCounts[b] += 1;
@@ -603753,15 +605130,32 @@ function formatLiveDashboardFromSnapshot(snapshot, opts = {}) {
     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 = [
       `├─ 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)) pushDashboardWrapped(lines, item, width);
+    for (const item of audioBits.slice(0, 9)) pushDashboardWrapped(lines, item, width);
   }
   lines.push(`╰${horizontal}╯`);
   return lines;
@@ -603945,15 +605339,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);
@@ -604001,7 +605403,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,
@@ -604015,7 +605417,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;
@@ -604025,16 +605427,22 @@ function formatLiveSensorContextFromSnapshot(snapshot, opts = {}) {
   if (!snapshot) return "";
   const now2 = opts.now ?? Date.now();
   const maxAgeMs = opts.maxAgeMs ?? 9e4;
+  const toolCapable = opts.toolCapable !== false;
   const lines = [];
   const activeVideo = snapshot.config.videoEnabled || Boolean(snapshot.video);
   const activeAudio = snapshot.config.audioEnabled || snapshot.config.audioOutputEnabled || Boolean(snapshot.audio);
   if (!activeVideo && !activeAudio) return "";
   lines.push("<live-sensor-context>");
   lines.push("## LIVE SENSOR STATUS");
-  lines.push("Live sensor context is operator-enabled ambient input. Treat it as current perceptual evidence for this turn; if it is stale, missing, or insufficient, use camera/audio tools to refresh before answering what you see or hear.");
-  lines.push('Live world-model rule: when the user asks what is around, who is present, what changed, what is heard, or asks a deictic question like "what do you see", treat the live camera/audio fields as first-class context. Be curious and tool-capable: refresh stale sensors, inspect frame paths, query vision/CLIP/visual_memory/audio tools, and combine metadata into a concise answer. Do not rely only on summaries when the task requires current perception.');
-  lines.push("Live speech rule: in low-latency voice/live modes, short spoken replies are appropriate for direct address, identity clarification, or important visual/audio triggers. Do not narrate every frame.");
-  lines.push("Identity rule: never invent names for observed people. If a person is unknown and identity matters, ask the user or the person for their name, then store the association with visual_memory(action='enroll', image='<face crop>', name='<name>') when a face crop is available, or multimodal_memory(action='meet', person_name='<name>') when live voice/name context is available.");
+  if (toolCapable) {
+    lines.push("Live sensor context is operator-enabled ambient input. Treat it as current perceptual evidence for this turn; if it is stale, missing, or insufficient, use camera/audio tools to refresh before answering what you see or hear.");
+    lines.push('Live world-model rule: when the user asks what is around, who is present, what changed, what is heard, or asks a deictic question like "what do you see", treat the live camera/audio fields as first-class context. Be curious and tool-capable: refresh stale sensors, inspect frame paths, query vision/CLIP/visual_memory/audio tools, and combine metadata into a concise answer. Do not rely only on summaries when the task requires current perception.');
+    lines.push("Live speech rule: in low-latency voice/live modes, short spoken replies are appropriate for direct address, identity clarification, or important visual/audio triggers. Do not narrate every frame.");
+    lines.push("Identity rule: never invent names for observed people. If a person is unknown and identity matters, ask the user or the person for their name, then store the association with visual_memory(action='enroll', image='<face crop>', name='<name>') when a face crop is available, or multimodal_memory(action='meet', person_name='<name>') when live voice/name context is available.");
+  } else {
+    lines.push("This is your current live perception: what the camera sees and what is heard right now. Answer questions about sight/sound directly from these fields.");
+    lines.push("If the data below is stale or missing, say you cannot see/hear clearly right now. Never invent observations or names for people. To have the main agent investigate further, relay a request with the voice_to_main tool.");
+  }
   lines.push(`Snapshot file: ${liveSnapshotPath(snapshot.repoRoot)}`);
   lines.push(`Streams: video=${snapshot.config.videoEnabled ? "on" : "off"} infer=${snapshot.config.inferEnabled ? "on" : "off"} clip=${snapshot.config.clipEnabled ? "on" : "off"} audio=${snapshot.config.audioEnabled ? "on" : "off"} asr=${snapshot.config.asrEnabled ? "on" : "off"} sounds=${snapshot.config.audioAnalysisEnabled ? "on" : "off"} output-monitor=${snapshot.config.audioOutputEnabled ? "on" : "off"}`);
   if (snapshot.config.selectedCamera) {
@@ -604177,8 +605585,8 @@ function formatLiveSensorContextFromSnapshot(snapshot, opts = {}) {
 ... live sensor context truncated ...
 </live-sensor-context>` : text2;
 }
-function formatLiveSensorContext(repoRoot) {
-  return formatLiveSensorContextFromSnapshot(readLiveSensorSnapshot(repoRoot));
+function formatLiveSensorContext(repoRoot, opts = {}) {
+  return formatLiveSensorContextFromSnapshot(readLiveSensorSnapshot(repoRoot), opts);
 }
 function isLiveSensorSnapshotActive(snapshot) {
   const cfg = snapshot?.config;
@@ -604220,12 +605628,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",
@@ -604236,8 +605645,7 @@ async function recordAudioSample(device, durationSec, outputPath3) {
       source,
       "-t",
       ffmpegSeconds,
-      "-ac",
-      "1",
+      ...channelArgs,
       "-ar",
       "16000",
       "-acodec",
@@ -604346,12 +605754,12 @@ 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;
-  return activity.peak >= 0.025 || activity.rmsDb > -48 || activity.activeRatio >= 0.025;
+  return activity.peak >= 0.012 || activity.rmsDb > -55 || activity.activeRatio >= 0.015;
 }
 function audioCaptureMethod(device) {
   return device.startsWith("pulse:") ? "pulse/ffmpeg" : "arecord";
@@ -604381,7 +605789,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);
@@ -604393,7 +605802,7 @@ async function recordAudioSampleWithRecovery(preferred, devices, durationSec, ou
           device: candidate,
           method,
           activity,
-          bytes: readFileSync88(outputPath3),
+          bytes: readFileSync89(outputPath3),
           errors: [...errors]
         };
       }
@@ -604403,7 +605812,7 @@ async function recordAudioSampleWithRecovery(preferred, devices, durationSec, ou
     }
   }
   if (firstQuietCapture) {
-    writeFileSync56(outputPath3, firstQuietCapture.bytes);
+    writeFileSync58(outputPath3, firstQuietCapture.bytes);
     return {
       ok: true,
       device: firstQuietCapture.device,
@@ -604499,6 +605908,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;
@@ -605167,7 +606577,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
         });
@@ -605216,7 +606626,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
@@ -605259,7 +606669,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 = "";
@@ -605571,7 +606981,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,
@@ -605579,7 +606989,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");
       }
     };
   }
@@ -605725,8 +607135,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;
@@ -605737,16 +607147,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));
       }
     }
   };
@@ -605771,15 +607181,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 [];
   }
@@ -605809,7 +607219,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);
@@ -605822,7 +607232,7 @@ async function runStaticRuntimeAssetSyntaxCheck(projectRoot, options2 = {}) {
       if (issueByAsset.has(assetFile)) continue;
       let source = "";
       try {
-        source = readFileSync89(assetFile, "utf8");
+        source = readFileSync90(assetFile, "utf8");
       } catch {
         continue;
       }
@@ -605895,1194 +607305,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) {
@@ -625732,6 +625954,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;
@@ -626545,6 +626771,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;
@@ -629222,10 +629460,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,
@@ -696176,6 +696423,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;
@@ -696190,6 +696450,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);
   }
@@ -696198,6 +696459,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) {
@@ -696206,7 +696470,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 };
       }
@@ -696224,18 +696489,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);
@@ -696374,6 +696659,7 @@ var init_voicechat = __esm({
     SYSTEM_PROMPT2 = `You are a voice assistant having a live spoken conversation. Keep responses extremely brief — 1-2 sentences max. You're speaking aloud, not writing. Be conversational, direct, and helpful. Don't use markdown or formatting — just natural speech.
 
 Rules:
+- Live perception: each turn you may receive a read-only "Context snapshot" system message containing what the camera currently sees (objects, people, classifications, recent visual events) and what is currently heard (sound scene, recent sounds, transcripts). Treat it as your own live sight and hearing. When the user asks what you see, who is there, or what you hear, answer directly from that snapshot. If the snapshot is missing or stale, say you can't see/hear clearly right now — do not invent observations.
 - Never invent environment facts (cwd, OS, specs, repo state). If you need a precise fact from the main agent, request a tool by outputting on a single line EXACTLY one JSON object: {"tool": string, "args": object} and nothing else. Then wait for the tool result before answering.
 - You may also request to relay a user task to the main agent by emitting {"tool":"voice_to_main","args":{"message":"...","start":true}}.
 - Prefer tools for factual queries; otherwise, answer directly with a short reply.
@@ -696475,12 +696761,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;
@@ -696623,7 +696909,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 });
@@ -735615,6 +735901,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);
       });
@@ -735919,6 +736208,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) {
@@ -736071,7 +736366,7 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
             } else {
               parts.push("active: no");
             }
-            const liveContext = formatLiveSensorContext(repoRoot);
+            const liveContext = formatLiveSensorContext(repoRoot, { toolCapable: false, maxChars: 7e3 });
             if (liveContext) parts.push(liveContext);
             return parts.join("\n");
           }