@johpaz/hive-agents 0.0.30 → 0.0.32

package/dist/hive.js

@@ -476741,18 +476741,320 @@ var init_models5 = __esm(() => {
   ];
 });
 
-// packages/core/src/gateway/routes/tts-local.ts
-import { existsSync as existsSync25, readdirSync as readdirSync4, readFileSync as readFileSync12 } from "fs";
+// packages/tts/src/detect.ts
+function detectPlatform() {
+  const os2 = process.platform;
+  const arch = process.arch;
+  if (os2 === "linux" && arch === "x64")
+    return "linux-x64";
+  if (os2 === "linux" && arch === "arm64")
+    return "linux-arm64";
+  if (os2 === "win32" && arch === "x64")
+    return "windows-x64";
+  if (os2 === "darwin" && arch === "x64")
+    return "macos-x64";
+  if (os2 === "darwin" && arch === "arm64")
+    return "macos-arm64";
+  throw new Error(`Plataforma no soportada: ${os2}/${arch}`);
+}
+function getPiperBinaryName(platform2) {
+  return platform2.startsWith("windows") ? "piper.exe" : "piper";
+}
+var PIPER_VERSION = "2023.11.14-2", PIPER_BASE_URL, PIPER_URLS, DEFAULT_VOICE = "es_MX-claude-14947-epoch-high", VOICE_BASE_URL = "https://huggingface.co/spaces/HirCoir/Piper-TTS-Spanish", VOICE_URLS;
+var init_detect = __esm(() => {
+  PIPER_BASE_URL = `https://github.com/rhasspy/piper/releases/download/${PIPER_VERSION}`;
+  PIPER_URLS = {
+    "linux-x64": `${PIPER_BASE_URL}/piper_linux_x86_64.tar.gz`,
+    "linux-arm64": `${PIPER_BASE_URL}/piper_linux_aarch64.tar.gz`,
+    "windows-x64": `${PIPER_BASE_URL}/piper_windows_amd64.zip`,
+    "macos-x64": `${PIPER_BASE_URL}/piper_macos_x86_64.tar.gz`,
+    "macos-arm64": `${PIPER_BASE_URL}/piper_macos_aarch64.tar.gz`
+  };
+  VOICE_URLS = {
+    model: `${VOICE_BASE_URL}/resolve/main/es_MX-claude-14947-epoch-high.onnx`,
+    config: `${VOICE_BASE_URL}/resolve/main/es_MX-claude-14947-epoch-high.onnx.json`
+  };
+});
+
+// packages/tts/src/install.ts
+import { existsSync as existsSync25, mkdirSync as mkdirSync15, readdirSync as readdirSync4, renameSync as renameSync2 } from "fs";
 import { join as join18 } from "path";
+async function downloadFile2(url2, dest) {
+  const filename = url2.split("/").pop();
+  log76.info(`Descargando ${filename}...`);
+  const res = await fetch(url2);
+  if (!res.ok)
+    throw new Error(`HTTP ${res.status} al descargar ${url2}`);
+  const buf = await res.arrayBuffer();
+  await Bun.write(dest, buf);
+  log76.info(`${filename} \u2014 ${(buf.byteLength / 1024 / 1024).toFixed(1)} MB`);
+}
+async function extractTarGz(archivePath, destDir) {
+  const code2 = await Bun.spawn(["tar", "-xzf", archivePath, "-C", destDir], {
+    stdout: "inherit",
+    stderr: "inherit"
+  }).exited;
+  if (code2 !== 0)
+    throw new Error(`tar fall\xF3 con c\xF3digo ${code2}`);
+  await Bun.spawn(["rm", "-f", archivePath]).exited;
+}
+async function extractZip(archivePath, destDir) {
+  const code2 = await Bun.spawn(["unzip", "-q", archivePath, "-d", destDir], {
+    stdout: "inherit",
+    stderr: "inherit"
+  }).exited;
+  if (code2 !== 0)
+    throw new Error(`unzip fall\xF3 con c\xF3digo ${code2}`);
+  await Bun.spawn(["rm", "-f", archivePath]).exited;
+}
+async function runInstall(ttsRoot) {
+  const BIN_DIR = join18(ttsRoot, "bin");
+  const VOICES_DIR = join18(ttsRoot, "voices");
+  mkdirSync15(BIN_DIR, { recursive: true });
+  mkdirSync15(VOICES_DIR, { recursive: true });
+  const platform2 = detectPlatform();
+  const binaryName = getPiperBinaryName(platform2);
+  const binaryPath = join18(BIN_DIR, binaryName);
+  if (!existsSync25(binaryPath)) {
+    const url2 = PIPER_URLS[platform2];
+    const archiveExt = url2.endsWith(".zip") ? ".zip" : ".tar.gz";
+    const archivePath = join18(BIN_DIR, `piper${archiveExt}`);
+    log76.info(`Instalando Piper para ${platform2}...`);
+    await downloadFile2(url2, archivePath);
+    log76.info("Extrayendo...");
+    if (archiveExt === ".zip") {
+      await extractZip(archivePath, BIN_DIR);
+    } else {
+      await extractTarGz(archivePath, BIN_DIR);
+    }
+    const piperSubdir = join18(BIN_DIR, "piper");
+    if (existsSync25(piperSubdir)) {
+      const tempDir = join18(BIN_DIR, "_piper_tmp");
+      renameSync2(piperSubdir, tempDir);
+      for (const entry of readdirSync4(tempDir)) {
+        renameSync2(join18(tempDir, entry), join18(BIN_DIR, entry));
+      }
+      await Bun.spawn(["rm", "-rf", tempDir]).exited;
+    }
+    if (!existsSync25(binaryPath)) {
+      throw new Error(`Binario no encontrado tras extracci\xF3n: ${binaryPath}`);
+    }
+    if (!platform2.startsWith("windows")) {
+      await Bun.spawn(["chmod", "+x", binaryPath]).exited;
+    }
+    log76.info(`Piper instalado en ${BIN_DIR}`);
+  } else {
+    log76.info("Piper ya instalado, omitiendo descarga.");
+  }
+  const modelPath = join18(VOICES_DIR, `${DEFAULT_VOICE}.onnx`);
+  const configPath = join18(VOICES_DIR, `${DEFAULT_VOICE}.onnx.json`);
+  if (!existsSync25(modelPath) || !existsSync25(configPath)) {
+    log76.info(`Descargando modelo de voz ${DEFAULT_VOICE}...`);
+    await downloadFile2(VOICE_URLS.model, modelPath);
+    await downloadFile2(VOICE_URLS.config, configPath);
+    log76.info(`Voz instalada en ${VOICES_DIR}`);
+  } else {
+    log76.info("Modelo de voz ya instalado, omitiendo descarga.");
+  }
+  log76.info("Hive TTS listo.");
+}
+var log76;
+var init_install = __esm(() => {
+  init_detect();
+  log76 = {
+    info: (msg) => console.log(`[TTS] ${msg}`),
+    warn: (msg) => console.warn(`[TTS] ${msg}`),
+    error: (msg) => console.error(`[TTS] ${msg}`)
+  };
+  if (false) {}
+});
+
+// packages/tts/src/server.ts
+import { existsSync as existsSync26, readdirSync as readdirSync5, readFileSync as readFileSync12 } from "fs";
+import { join as join19 } from "path";
+import { homedir as homedir3 } from "os";
+function getPiperPath() {
+  const platform2 = detectPlatform();
+  const binaryName = getPiperBinaryName(platform2);
+  const binaryPath = join19(BIN_DIR, binaryName);
+  if (!existsSync26(binaryPath)) {
+    throw new Error("Piper no instalado. Ejecuta: bun run src/install.ts");
+  }
+  return binaryPath;
+}
+function listVoices() {
+  if (!existsSync26(VOICES_DIR))
+    return [];
+  return readdirSync5(VOICES_DIR).filter((f2) => f2.endsWith(".onnx")).map((f2) => f2.replace(".onnx", ""));
+}
+async function synthesize(text2, voice) {
+  const piperPath = getPiperPath();
+  const modelPath = join19(VOICES_DIR, `${voice}.onnx`);
+  const configPath = join19(VOICES_DIR, `${voice}.onnx.json`);
+  if (!existsSync26(modelPath)) {
+    throw new Error(`Voz no encontrada: ${voice}`);
+  }
+  let lengthScale = 0.95;
+  let noiseScale = 0.6;
+  let noiseW = 0.75;
+  let sentenceSilence = 0.2;
+  if (existsSync26(configPath)) {
+    try {
+      const config2 = JSON.parse(readFileSync12(configPath, "utf-8"));
+      const inference = config2.inference || {};
+      lengthScale = (inference.length_scale ?? 1) * 0.95;
+      noiseScale = (inference.noise_scale ?? 0.667) * 0.9;
+      noiseW = (inference.noise_w ?? 0.8) * 0.95;
+    } catch (err) {
+      log77.warn(`No se pudo leer configuraci\xF3n del modelo: ${err}`);
+    }
+  }
+  lengthScale = Number(process.env.PIPER_LENGTH_SCALE ?? lengthScale);
+  noiseScale = Number(process.env.PIPER_NOISE_SCALE ?? noiseScale);
+  noiseW = Number(process.env.PIPER_NOISE_W ?? noiseW);
+  sentenceSilence = Number(process.env.PIPER_SENTENCE_SILENCE ?? sentenceSilence);
+  const args = [
+    piperPath,
+    "--model",
+    modelPath,
+    "--output-raw",
+    "--length_scale",
+    String(lengthScale),
+    "--noise_scale",
+    String(noiseScale),
+    "--noise_w",
+    String(noiseW),
+    "--sentence_silence",
+    String(sentenceSilence)
+  ];
+  const proc = Bun.spawn(args, {
+    stdin: "pipe",
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  proc.stdin.write(new TextEncoder().encode(text2));
+  proc.stdin.end();
+  const [audioBuffer, exitCode] = await Promise.all([
+    new Response(proc.stdout).arrayBuffer(),
+    proc.exited
+  ]);
+  if (exitCode !== 0) {
+    const errText = await new Response(proc.stderr).text();
+    throw new Error(`Piper error (exit ${exitCode}): ${errText}`);
+  }
+  return wrapInWav(audioBuffer, 22050, 1, 16);
+}
+function wrapInWav(pcm, sampleRate, channels, bitsPerSample) {
+  const dataSize = pcm.byteLength;
+  const header = new ArrayBuffer(44);
+  const view = new DataView(header);
+  const writeStr = (offset, str2) => {
+    for (let i3 = 0;i3 < str2.length; i3++)
+      view.setUint8(offset + i3, str2.charCodeAt(i3));
+  };
+  writeStr(0, "RIFF");
+  view.setUint32(4, 36 + dataSize, true);
+  writeStr(8, "WAVE");
+  writeStr(12, "fmt ");
+  view.setUint32(16, 16, true);
+  view.setUint16(20, 1, true);
+  view.setUint16(22, channels, true);
+  view.setUint32(24, sampleRate, true);
+  view.setUint32(28, sampleRate * channels * bitsPerSample / 8, true);
+  view.setUint16(32, channels * bitsPerSample / 8, true);
+  view.setUint16(34, bitsPerSample, true);
+  writeStr(36, "data");
+  view.setUint32(40, dataSize, true);
+  const wav = new Uint8Array(44 + dataSize);
+  wav.set(new Uint8Array(header), 0);
+  wav.set(new Uint8Array(pcm), 44);
+  return wav.buffer;
+}
+function startTTSServer(opts) {
+  const listenPort = opts?.port ?? PORT;
+  const server = Bun.serve({
+    port: listenPort,
+    async fetch(req) {
+      const url2 = new URL(req.url);
+      if (req.method === "OPTIONS") {
+        return new Response(null, { status: 204, headers: CORS });
+      }
+      if (req.method === "GET" && url2.pathname === "/health") {
+        return Response.json({ ok: true, voice: DEFAULT_VOICE_ENV, voices: listVoices() }, { headers: CORS });
+      }
+      if (req.method === "GET" && url2.pathname === "/voices") {
+        return Response.json({ voices: listVoices() }, { headers: CORS });
+      }
+      if (req.method === "POST" && url2.pathname === "/tts") {
+        let body;
+        try {
+          body = await req.json();
+        } catch {
+          return Response.json({ error: "Body JSON inv\xE1lido" }, { status: 400, headers: CORS });
+        }
+        const { text: text2, voice = DEFAULT_VOICE_ENV } = body;
+        if (!text2 || typeof text2 !== "string" || text2.trim().length === 0) {
+          return Response.json({ error: "Campo 'text' requerido" }, { status: 400, headers: CORS });
+        }
+        if (text2.length > 2000) {
+          return Response.json({ error: "Texto demasiado largo (m\xE1x 2000 chars)" }, { status: 400, headers: CORS });
+        }
+        try {
+          const audio = await synthesize(text2.trim(), voice);
+          return new Response(audio, {
+            headers: {
+              ...CORS,
+              "Content-Type": "audio/wav",
+              "Content-Length": String(audio.byteLength)
+            }
+          });
+        } catch (err) {
+          const message = err instanceof Error ? err.message : "Error interno";
+          return Response.json({ error: message }, { status: 500, headers: CORS });
+        }
+      }
+      return Response.json({ error: "Not found" }, { status: 404, headers: CORS });
+    }
+  });
+  log77.info(`Hive TTS Server escuchando en http://localhost:${listenPort}`);
+  log77.info(`Voz por defecto: ${DEFAULT_VOICE_ENV}`);
+  log77.info(`Voces disponibles: ${listVoices().join(", ") || "ninguna (ejecuta install.ts primero)"}`);
+  return server;
+}
+var log77, TTS_ROOT, BIN_DIR, VOICES_DIR, PORT, DEFAULT_VOICE_ENV, CORS;
+var init_server = __esm(() => {
+  init_detect();
+  log77 = {
+    info: (msg) => console.log(`[TTS] ${msg}`),
+    warn: (msg) => console.warn(`[TTS] ${msg}`),
+    error: (msg) => console.error(`[TTS] ${msg}`)
+  };
+  TTS_ROOT = process.env.HIVE_TTS_ROOT ?? join19(process.env.HIVE_HOME ?? join19(homedir3(), ".hive"), "tts");
+  BIN_DIR = join19(TTS_ROOT, "bin");
+  VOICES_DIR = join19(TTS_ROOT, "voices");
+  PORT = Number(process.env.TTS_PORT ?? 5500);
+  DEFAULT_VOICE_ENV = process.env.TTS_VOICE ?? DEFAULT_VOICE;
+  CORS = {
+    "Access-Control-Allow-Origin": "*",
+    "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+    "Access-Control-Allow-Headers": "Content-Type"
+  };
+  if (false) {}
+});
+
+// packages/core/src/gateway/routes/tts-local.ts
+import { existsSync as existsSync27, readdirSync as readdirSync6, readFileSync as readFileSync13 } from "fs";
+import { join as join20 } from "path";
+import { homedir as homedir4 } from "os";
 function isInstalled() {
-  const piperExists = existsSync25(BIN_PATH);
+  const piperExists = existsSync27(BIN_PATH);
   const voiceExists = getInstalledVoices().length > 0;
   return { piperExists, voiceExists, installed: piperExists && voiceExists };
 }
 function getInstalledVoices() {
-  if (!existsSync25(VOICES_DIR))
+  if (!existsSync27(VOICES_DIR2))
     return [];
-  const files = readdirSync4(VOICES_DIR);
+  const files = readdirSync6(VOICES_DIR2);
   return files.filter((f2) => f2.endsWith(".onnx")).map((f2) => f2.replace(".onnx", ""));
 }
 async function isRunning() {
@@ -476780,7 +477082,7 @@ async function handleGetLocalTTSStatus(req, addCors) {
   }), req);
 }
 async function handleGetLocalTTSLogs(req, addCors) {
-  return addCors(Response.json({ logs: installLogs.slice(-100), ttsRoot: TTS_ROOT, bunPath: process.execPath }), req);
+  return addCors(Response.json({ logs: installLogs.slice(-100), ttsRoot: TTS_ROOT2, bunPath: process.execPath }), req);
 }
 async function handleInstallLocalTTS(req, addCors) {
   if (installing) {
@@ -476789,57 +477091,28 @@ async function handleInstallLocalTTS(req, addCors) {
   if (isInstalled().installed) {
     return addCors(Response.json({ started: false, reason: "Piper ya est\xE1 instalado" }), req);
   }
-  const installScript = join18(TTS_ROOT, "src", "install.ts");
-  if (!existsSync25(installScript)) {
-    return addCors(Response.json({
-      started: false,
-      reason: `Script no encontrado: ${installScript}. Verifica que packages/tts existe.`
-    }, { status: 500 }), req);
-  }
   installing = true;
   installLogs = [`[${new Date().toISOString()}] Iniciando instalaci\xF3n de Piper...`];
-  installLogs.push(`  TTS_ROOT: ${TTS_ROOT}`);
-  installLogs.push(`  Script: ${installScript}`);
-  installLogs.push(`  Bun: ${process.execPath}`);
-  const proc = Bun.spawn([process.execPath, installScript], {
-    stdout: "pipe",
-    stderr: "pipe",
-    cwd: TTS_ROOT
-  });
-  (async () => {
-    const reader = proc.stdout.getReader();
-    const decoder = new TextDecoder;
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done)
-        break;
-      const line = decoder.decode(value).trim();
-      if (line)
-        installLogs.push(line);
-    }
-  })();
-  (async () => {
-    const reader = proc.stderr.getReader();
-    const decoder = new TextDecoder;
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done)
-        break;
-      const line = decoder.decode(value).trim();
-      if (line) {
-        installLogs.push(`[stderr] ${line}`);
-        console.error(`[hive-tts install] ${line}`);
-      }
-    }
-  })();
-  proc.exited.then((code2) => {
-    installing = false;
-    installLogs.push(`[${new Date().toISOString()}] Proceso finalizado con c\xF3digo ${code2}`);
-    if (code2 !== 0)
-      console.error(`[hive-tts install] Fall\xF3 con c\xF3digo ${code2}`);
+  installLogs.push(`  TTS_ROOT: ${TTS_ROOT2}`);
+  const origLog = console.log;
+  const origWarn = console.warn;
+  console.log = (...args) => {
+    installLogs.push(args.join(" "));
+    origLog(...args);
+  };
+  console.warn = (...args) => {
+    installLogs.push(`[warn] ${args.join(" ")}`);
+    origWarn(...args);
+  };
+  runInstall(TTS_ROOT2).then(() => {
+    installLogs.push(`[${new Date().toISOString()}] Instalaci\xF3n completada`);
   }).catch((err) => {
+    installLogs.push(`[error] ${err instanceof Error ? err.message : String(err)}`);
+    console.error(`[hive-tts install] Fall\xF3: ${err}`);
+  }).finally(() => {
     installing = false;
-    installLogs.push(`[error] ${err}`);
+    console.log = origLog;
+    console.warn = origWarn;
   });
   return addCors(Response.json({ started: true }), req);
 }
@@ -476850,48 +477123,27 @@ async function handleStartLocalTTS(req, addCors) {
   if (!isInstalled().installed) {
     return addCors(Response.json({ started: false, reason: "Piper no est\xE1 instalado. Inst\xE1lalo primero." }, { status: 400 }), req);
   }
-  const serverScript = join18(TTS_ROOT, "src", "server.ts");
-  ttsProcess = Bun.spawn([process.execPath, serverScript], {
-    stdout: "pipe",
-    stderr: "pipe",
-    env: { ...process.env, TTS_PORT: String(TTS_PORT) },
-    cwd: TTS_ROOT
-  });
-  (async () => {
-    const reader = ttsProcess.stderr.getReader();
-    const decoder = new TextDecoder;
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done)
-        break;
-      const line = decoder.decode(value).trim();
-      if (line) {
-        installLogs.push(`[tts-server] ${line}`);
-        console.error(`[tts-server] ${line}`);
-      }
-    }
-  })();
+  try {
+    ttsServer = startTTSServer({ port: TTS_PORT });
+    installLogs.push(`[tts-server] Servidor TTS iniciado en puerto ${TTS_PORT}`);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`[tts-server] Fall\xF3 al iniciar: ${msg}`);
+    installLogs.push(`[error] Servidor TTS fall\xF3 al iniciar: ${msg}`);
+    return addCors(Response.json({ started: false, reason: msg }), req);
+  }
   for (let i3 = 0;i3 < 6; i3++) {
     await Bun.sleep(500);
     if (await isRunning())
       break;
   }
   const running = await isRunning();
-  if (!running) {
-    const exitCode = await ttsProcess.exited;
-    console.error(`[tts-server] Fall\xF3 al iniciar, exit code: ${exitCode}`);
-    installLogs.push(`[error] Servidor TTS fall\xF3 al iniciar (c\xF3digo ${exitCode})`);
-  }
   return addCors(Response.json({ started: running }), req);
 }
 async function handleStopLocalTTS(req, addCors) {
-  if (ttsProcess) {
-    ttsProcess.kill();
-    ttsProcess = null;
-  } else {
-    try {
-      Bun.spawn(["pkill", "-f", "tts/src/server.ts"]);
-    } catch {}
+  if (ttsServer) {
+    ttsServer.stop(true);
+    ttsServer = null;
   }
   return addCors(Response.json({ stopped: true }), req);
 }
@@ -476900,15 +477152,11 @@ async function ensureTTSRunning() {
     return true;
   if (!isInstalled().installed)
     return false;
-  const serverScript = join18(TTS_ROOT, "src", "server.ts");
-  if (!existsSync25(serverScript))
+  try {
+    ttsServer = startTTSServer({ port: TTS_PORT });
+  } catch {
     return false;
-  ttsProcess = Bun.spawn([process.execPath, serverScript], {
-    stdout: "pipe",
-    stderr: "pipe",
-    env: { ...process.env, TTS_PORT: String(TTS_PORT) },
-    cwd: TTS_ROOT
-  });
+  }
   for (let i3 = 0;i3 < 10; i3++) {
     await Bun.sleep(500);
     if (await isRunning())
@@ -476965,10 +477213,10 @@ async function handleGetInstalledVoices(req, addCors) {
   const voices = getInstalledVoices().map((id) => {
     const model = getModelById(id);
     let inferenceConfig = { length_scale: 1, noise_scale: 0.667, noise_w: 0.8 };
-    const configPath = join18(VOICES_DIR, `${id}.onnx.json`);
-    if (existsSync25(configPath)) {
+    const configPath = join20(VOICES_DIR2, `${id}.onnx.json`);
+    if (existsSync27(configPath)) {
       try {
-        const config2 = JSON.parse(readFileSync12(configPath, "utf-8"));
+        const config2 = JSON.parse(readFileSync13(configPath, "utf-8"));
         inferenceConfig = { ...inferenceConfig, ...config2.inference };
       } catch {}
     }
@@ -477010,8 +477258,8 @@ async function handleDownloadModel(req, addCors) {
   downloadLogs = [`[${new Date().toISOString()}] Iniciando descarga de ${model.name}...`];
   (async () => {
     try {
-      const modelDest = join18(VOICES_DIR, `${modelId}.onnx`);
-      const configDest = join18(VOICES_DIR, `${modelId}.onnx.json`);
+      const modelDest = join20(VOICES_DIR2, `${modelId}.onnx`);
+      const configDest = join20(VOICES_DIR2, `${modelId}.onnx.json`);
       downloadLogs.push(`  Descargando modelo: ${model.size}`);
       downloadLogs.push(`  URL: ${model.modelUrl}`);
       const modelRes = await fetch(model.modelUrl);
@@ -477046,12 +477294,14 @@ async function handleGetDownloadLogs(req, addCors) {
     currentModelId: downloadingModelId
   }), req);
 }
-var TTS_ROOT, BIN_PATH, VOICES_DIR, TTS_PORT, ttsProcess = null, installing = false, installLogs, downloadingModelId = null, downloadLogs;
+var TTS_ROOT2, BIN_PATH, VOICES_DIR2, TTS_PORT, ttsServer = null, installing = false, installLogs, downloadingModelId = null, downloadLogs;
 var init_tts_local = __esm(() => {
   init_models5();
-  TTS_ROOT = join18(import.meta.dir, "../../../../tts");
-  BIN_PATH = join18(TTS_ROOT, "bin", process.platform === "win32" ? "piper.exe" : "piper");
-  VOICES_DIR = join18(TTS_ROOT, "voices");
+  init_install();
+  init_server();
+  TTS_ROOT2 = process.env.HIVE_TTS_ROOT ?? join20(process.env.HIVE_HOME ?? join20(homedir4(), ".hive"), "tts");
+  BIN_PATH = join20(TTS_ROOT2, "bin", process.platform === "win32" ? "piper.exe" : "piper");
+  VOICES_DIR2 = join20(TTS_ROOT2, "voices");
   TTS_PORT = Number(process.env.TTS_PORT ?? 5500);
   installLogs = [];
   downloadLogs = [];
@@ -477067,10 +477317,10 @@ async function handleCreateMeeting(req, addCorsHeaders) {
     const result = db.query(`INSERT INTO meeting_sessions (title, stt_model)
          VALUES (?, ?)
          RETURNING id, title, status, stt_model, started_at`).get(title, sttModel);
-    log76.info(`Meeting session created: ${result.id}`);
+    log78.info(`Meeting session created: ${result.id}`);
     return addCorsHeaders(Response.json({ ok: true, session: result }), req);
   } catch (error54) {
-    log76.error(`handleCreateMeeting: ${error54.message}`);
+    log78.error(`handleCreateMeeting: ${error54.message}`);
     return addCorsHeaders(Response.json({ ok: false, error: error54.message }, { status: 500 }), req);
   }
 }
@@ -477085,7 +477335,7 @@ async function handleListMeetings(req, addCorsHeaders) {
          LIMIT 50`).all();
     return addCorsHeaders(Response.json({ ok: true, sessions }), req);
   } catch (error54) {
-    log76.error(`handleListMeetings: ${error54.message}`);
+    log78.error(`handleListMeetings: ${error54.message}`);
     return addCorsHeaders(Response.json({ ok: false, error: error54.message }, { status: 500 }), req);
   }
 }
@@ -477100,7 +477350,7 @@ async function handleGetMeeting(req, addCorsHeaders, sessionId) {
          WHERE session_id = ? ORDER BY seq ASC`).all(sessionId);
     return addCorsHeaders(Response.json({ ok: true, session, segments }), req);
   } catch (error54) {
-    log76.error(`handleGetMeeting: ${error54.message}`);
+    log78.error(`handleGetMeeting: ${error54.message}`);
     return addCorsHeaders(Response.json({ ok: false, error: error54.message }, { status: 500 }), req);
   }
 }
@@ -477128,7 +477378,7 @@ async function handleAddMeetingSegment(req, addCorsHeaders, sessionId) {
     db.query(`INSERT INTO meeting_segments (session_id, seq, speaker, text) VALUES (?, ?, ?, ?)`).run(sessionId, seq, speaker, transcription);
     return addCorsHeaders(Response.json({ ok: true, seq, speaker, text: transcription }), req);
   } catch (error54) {
-    log76.error(`handleAddMeetingSegment: ${error54.message}`);
+    log78.error(`handleAddMeetingSegment: ${error54.message}`);
     return addCorsHeaders(Response.json({ ok: false, error: error54.message }, { status: 500 }), req);
   }
 }
@@ -477145,7 +477395,7 @@ async function handleStopMeeting(req, addCorsHeaders, sessionId) {
     }
     db.query(`UPDATE meeting_sessions SET status = 'stopped', stopped_at = unixepoch() WHERE id = ?`).run(sessionId);
     const countResult = db.query(`SELECT COUNT(*) as count FROM meeting_segments WHERE session_id = ?`).get(sessionId);
-    log76.info(`Meeting stopped: ${sessionId} \u2014 ${countResult.count} segments`);
+    log78.info(`Meeting stopped: ${sessionId} \u2014 ${countResult.count} segments`);
     return addCorsHeaders(Response.json({
       ok: true,
       session_id: sessionId,
@@ -477153,16 +477403,16 @@ async function handleStopMeeting(req, addCorsHeaders, sessionId) {
       segment_count: countResult.count
     }), req);
   } catch (error54) {
-    log76.error(`handleStopMeeting: ${error54.message}`);
+    log78.error(`handleStopMeeting: ${error54.message}`);
     return addCorsHeaders(Response.json({ ok: false, error: error54.message }, { status: 500 }), req);
   }
 }
-var log76;
+var log78;
 var init_meeting2 = __esm(() => {
   init_sqlite();
   init_voice();
   init_logger();
-  log76 = logger.child("meeting-routes");
+  log78 = logger.child("meeting-routes");
 });
 
 // package.json
@@ -477170,7 +477420,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@johpaz/hive-agents",
-    version: "0.0.30",
+    version: "0.0.32",
     description: "Tu colmena de agentes IA. Local-first. Multi-canal. Open source. Construido desde Colombia para el mundo.",
     private: false,
     bin: {
@@ -477667,7 +477917,7 @@ async function handleChat(req, addCorsHeaders) {
     const finalUserId = userId || resolveUserId({ channel }) || "default";
     const finalAgentId = agentId || resolveAgentId(null) || "main";
     const threadId = thread_id || `${finalUserId}-${Date.now()}`;
-    log77.info(`[chat] Processing message from user=${finalUserId} agent=${finalAgentId} thread=${threadId}`);
+    log79.info(`[chat] Processing message from user=${finalUserId} agent=${finalAgentId} thread=${threadId}`);
     const userRow = db.query("SELECT timezone FROM users WHERE id = ?").get(finalUserId);
     const userTimezone = userRow?.timezone || "UTC";
     const now = new Date;
@@ -477700,7 +477950,7 @@ ${message}`;
       if (signal2.aborted)
         return;
       try {
-        log77.info(`[chat] Generating response for thread ${threadId}...`);
+        log79.info(`[chat] Generating response for thread ${threadId}...`);
         const response = await runner.generate({
           provider,
           messages: messages2,
@@ -477712,17 +477962,17 @@ ${message}`;
           channel,
           onStep: async (step) => {
             if (step.type === "text" && step.message) {
-              log77.debug(`[chat] Step: ${step.message.substring(0, 100)}`);
+              log79.debug(`[chat] Step: ${step.message.substring(0, 100)}`);
             }
             if (step.type === "tool_result" && step.message) {
-              log77.debug(`[chat] Tool result: ${step.message.substring(0, 100)}`);
+              log79.debug(`[chat] Tool result: ${step.message.substring(0, 100)}`);
             }
           }
         });
         responseContent = response.content?.trim() || "Task completed.";
-        log77.info(`[chat] Response generated: ${responseContent.substring(0, 100)}...`);
+        log79.info(`[chat] Response generated: ${responseContent.substring(0, 100)}...`);
       } catch (error54) {
-        log77.error(`[chat] Error for thread ${threadId}: ${error54.message}`);
+        log79.error(`[chat] Error for thread ${threadId}: ${error54.message}`);
         responseError = error54.message;
       }
     });
@@ -477751,7 +478001,7 @@ ${message}`;
       content: responseContent
     }), req);
   } catch (error54) {
-    log77.error(`[chat] Handler error: ${error54.message}`);
+    log79.error(`[chat] Handler error: ${error54.message}`);
     return addCorsHeaders(Response.json({
       success: false,
       error: error54.message,
@@ -477780,7 +478030,7 @@ async function handleGetNotes(req, addCorsHeaders) {
   `).all();
   return addCorsHeaders(Response.json({ notes }), req);
 }
-var log77;
+var log79;
 var init_chat3 = __esm(() => {
   init_sqlite();
   init_onboarding();
@@ -477788,7 +478038,7 @@ var init_chat3 = __esm(() => {
   init_conversation_store();
   init_providers3();
   init_logger();
-  log77 = logger.child("api:chat");
+  log79 = logger.child("api:chat");
 });
 
 // packages/core/src/gateway/helpers/redact.ts
@@ -477844,7 +478094,7 @@ async function handleGetConfig(req, addCorsHeaders, config2) {
 var init_config = () => {};
 
 // packages/core/src/gateway/routes/workspace.ts
-import { mkdirSync as mkdirSync15, existsSync as existsSync26, accessSync, constants as constants2 } from "fs";
+import { mkdirSync as mkdirSync16, existsSync as existsSync28, accessSync, constants as constants2 } from "fs";
 import * as path28 from "path";
 import { exec as exec2 } from "child_process";
 import { promisify as promisify4 } from "util";
@@ -477870,7 +478120,7 @@ async function handleValidateWorkspace(req, addCorsHeaders) {
         isAbsolute: false
       }), req);
     }
-    const exists = existsSync26(workspacePath);
+    const exists = existsSync28(workspacePath);
     if (!exists) {
       return addCorsHeaders(Response.json({
         ok: true,
@@ -477923,7 +478173,7 @@ async function handleCreateWorkspace(req, addCorsHeaders) {
         error: "El path debe ser absoluto"
       }), req);
     }
-    mkdirSync15(workspacePath, { recursive: true });
+    mkdirSync16(workspacePath, { recursive: true });
     return addCorsHeaders(Response.json({
       ok: true,
       path: workspacePath,
@@ -477952,7 +478202,7 @@ async function handleOpenWorkspace(req, addCorsHeaders) {
         error: "El path debe ser absoluto"
       }), req);
     }
-    if (!existsSync26(workspacePath)) {
+    if (!existsSync28(workspacePath)) {
       return addCorsHeaders(Response.json({
         ok: false,
         error: "El directorio no existe"
@@ -477999,7 +478249,7 @@ Define ethical guidelines here.`
 async function handleUpdateWorkspace(req, addCorsHeaders, workspacePath, wsType, reloadFn) {
   const content = await req.text();
   const filePath = path28.join(workspacePath, `${wsType.toUpperCase()}.md`);
-  mkdirSync15(workspacePath, { recursive: true });
+  mkdirSync16(workspacePath, { recursive: true });
   await Bun.write(filePath, content);
   if (reloadFn) {
     await reloadFn(wsType);
@@ -478111,7 +478361,7 @@ var init_helpers = __esm(() => {
 });
 
 // packages/core/src/gateway/server.ts
-import { mkdirSync as mkdirSync16, unlinkSync as unlinkSync4, existsSync as existsSync27, writeFileSync as writeFileSync11, readFileSync as readFileSync13 } from "fs";
+import { mkdirSync as mkdirSync17, unlinkSync as unlinkSync4, existsSync as existsSync29, writeFileSync as writeFileSync11, readFileSync as readFileSync14 } from "fs";
 import * as path30 from "path";
 import { cpus as osCpus } from "os";
 import { randomUUID as randomUUID2 } from "crypto";
@@ -478123,23 +478373,23 @@ async function startGateway(config2) {
   const numCores = osCpus().length || 1;
   let lastCpuSample = process.cpuUsage();
   let lastCpuSampleTime = Date.now();
-  const log78 = logger.child("gateway");
-  log78.info(`Starting gateway on ${host}:${port}`);
+  const log80 = logger.child("gateway");
+  log80.info(`Starting gateway on ${host}:${port}`);
   const tokenFile = path30.join(getHiveDir(), ".auth_token");
   if (!process.env.HIVE_AUTH_TOKEN) {
-    if (existsSync27(tokenFile)) {
-      process.env.HIVE_AUTH_TOKEN = readFileSync13(tokenFile, "utf-8").trim();
-      log78.info("\uD83D\uDD11 Auth token loaded from persistent storage");
+    if (existsSync29(tokenFile)) {
+      process.env.HIVE_AUTH_TOKEN = readFileSync14(tokenFile, "utf-8").trim();
+      log80.info("\uD83D\uDD11 Auth token loaded from persistent storage");
     } else {
       const generated = randomUUID2().replace(/-/g, "");
       process.env.HIVE_AUTH_TOKEN = generated;
-      mkdirSync16(path30.dirname(tokenFile), { recursive: true });
+      mkdirSync17(path30.dirname(tokenFile), { recursive: true });
       writeFileSync11(tokenFile, generated, { mode: 384 });
-      log78.info("\uD83D\uDD11 Auth token auto-generated and persisted");
+      log80.info("\uD83D\uDD11 Auth token auto-generated and persisted");
     }
   } else {
     writeFileSync11(tokenFile, process.env.HIVE_AUTH_TOKEN, { mode: 384 });
-    log78.info("\uD83D\uDD11 Auth token loaded from environment variable");
+    log80.info("\uD83D\uDD11 Auth token loaded from environment variable");
   }
   let agent;
   let runner;
@@ -478169,7 +478419,7 @@ async function startGateway(config2) {
     },
     websocket: { open() {}, message() {}, close() {} }
   });
-  log78.info(`Port ${port} bound (initializing gateway...)`);
+  log80.info(`Port ${port} bound (initializing gateway...)`);
   try {
     const db = initializeDatabase();
     seedAllData();
@@ -478192,9 +478442,9 @@ async function startGateway(config2) {
       await channelManager.send(channel, sessionId, { content, type: "progress" });
     });
     if (gatewaySetupMode) {
-      log78.info("\uD83C\uDF89 Setup mode: gateway running \u2014 open http://localhost:" + port + "/setup to configure");
+      log80.info("\uD83C\uDF89 Setup mode: gateway running \u2014 open http://localhost:" + port + "/setup to configure");
     } else {
-      log78.info("\u2705 Gateway initialization completed successfully");
+      log80.info("\u2705 Gateway initialization completed successfully");
       try {
         const db = getDb();
         db.query(`
@@ -478208,21 +478458,21 @@ async function startGateway(config2) {
         setSchedulerInstance(scheduler);
         setSchedulerInstance2(scheduler);
         setSchedulerForCleanup(scheduler);
-        log78.info(`\uD83D\uDCC5 CronScheduler initialized with ${scheduler.getStatus().length} task(s)`);
+        log80.info(`\uD83D\uDCC5 CronScheduler initialized with ${scheduler.getStatus().length} task(s)`);
         const dagScheduler = new DAGScheduler({ strategy: new ParallelStrategy, maxConcurrentWorkers: 2 });
         globalThis.__dagScheduler = dagScheduler;
-        log78.info("\uD83D\uDD00 DAGScheduler ready");
+        log80.info("\uD83D\uDD00 DAGScheduler ready");
       } catch (err) {
-        log78.error(`\u274C CronScheduler initialization failed: ${err.message}`);
+        log80.error(`\u274C CronScheduler initialization failed: ${err.message}`);
       }
     }
   } catch (error54) {
-    log78.error(`\u274C Gateway initialization failed: ${error54.message}`);
-    log78.error("Stack trace:", error54.stack);
+    log80.error(`\u274C Gateway initialization failed: ${error54.message}`);
+    log80.error("Stack trace:", error54.stack);
     process.exit(1);
   }
   if (host === "0.0.0.0" && config2.security?.warnOnInsecureConfig !== false) {
-    log78.warn("Gateway binding to 0.0.0.0 exposes server to all network interfaces!");
+    log80.warn("Gateway binding to 0.0.0.0 exposes server to all network interfaces!");
   }
   function prepareTools(agentInstance, sessionId) {
     return;
@@ -478230,8 +478480,8 @@ async function startGateway(config2) {
   const watchers = [];
   if (!gatewaySetupMode)
     channelManager.onMessage(async (message) => {
-      log78.info(`\uD83D\uDCE5 Message from ${message.channel}:${message.accountId}`);
-      log78.info(`   Session: ${message.sessionId}`);
+      log80.info(`\uD83D\uDCE5 Message from ${message.channel}:${message.accountId}`);
+      log80.info(`   Session: ${message.sessionId}`);
       const voiceConfig = voiceService.getChannelVoiceConfig(message.channel);
       const visionConfig = multimodalService.getChannelVisionConfig(message.channel);
       let messageContent = message.content;
@@ -478240,9 +478490,9 @@ async function startGateway(config2) {
       let sttProviderUsed = null;
       let contentParts;
       if (voiceConfig.voiceEnabled && message.audio) {
-        log78.info(`\uD83C\uDF99\uFE0F Voice enabled, processing audio...`);
+        log80.info(`\uD83C\uDF99\uFE0F Voice enabled, processing audio...`);
         if (!voiceConfig.sttProvider) {
-          log78.warn(`\u26A0\uFE0F STT provider not configured for channel ${message.channel}`);
+          log80.warn(`\u26A0\uFE0F STT provider not configured for channel ${message.channel}`);
           await channelManager.send(message.channel, message.sessionId, {
             content: `\uD83C\uDF99\uFE0F Para usar notas de voz, necesitas configurar el proveedor STT en la configuraci\xF3n del canal. Ve a Configuraci\xF3n > Canales > [Tu canal] y configura "Prov. STT" (ej: groq-whisper o openai)`
           });
@@ -478252,7 +478502,7 @@ async function startGateway(config2) {
           const audioInput = voiceService.normalizeAudioFromChannel(message.channel, message.audio);
           sttProviderUsed = voiceConfig.sttProvider || "groq-whisper";
           messageContent = await voiceService.transcribe(audioInput, sttProviderUsed);
-          log78.info(`\uD83D\uDCDD Transcribed: ${messageContent.substring(0, 100)}...`);
+          log80.info(`\uD83D\uDCDD Transcribed: ${messageContent.substring(0, 100)}...`);
           inputType = "audio_transcribed";
           preferAudioResponse = !!voiceConfig.ttsProvider;
           await channelManager.send(message.channel, message.sessionId, {
@@ -478260,7 +478510,7 @@ async function startGateway(config2) {
             type: "message"
           });
         } catch (error54) {
-          log78.error(`\u274C Transcription failed: ${error54.message}`);
+          log80.error(`\u274C Transcription failed: ${error54.message}`);
           await channelManager.send(message.channel, message.sessionId, {
             content: `Error al transcribir audio: ${error54.message}`
           });
@@ -478268,7 +478518,7 @@ async function startGateway(config2) {
         }
       }
       if (message.image || message.document) {
-        log78.info(`\uD83D\uDDBC\uFE0F Multimodal content detected on channel ${message.channel}`);
+        log80.info(`\uD83D\uDDBC\uFE0F Multimodal content detected on channel ${message.channel}`);
         if (message.image) {
           try {
             const imageInput = multimodalService.normalizeImageFromChannel(message.channel, message.image);
@@ -478278,20 +478528,20 @@ async function startGateway(config2) {
             if (visionConfig.visionEnabled && modelHasVision) {
               contentParts = await multimodalService.processImage(imageInput, visionConfig.visionModelId || undefined);
               inputType = "image";
-              log78.info(`\uD83D\uDDBC\uFE0F Image sent as vision ContentParts (model supports vision)`);
+              log80.info(`\uD83D\uDDBC\uFE0F Image sent as vision ContentParts (model supports vision)`);
             } else {
               const ocrProvider = visionConfig.ocrProvider || "openai";
-              log78.info(`\uD83D\uDDBC\uFE0F Model lacks vision, using OCR via ${ocrProvider}...`);
+              log80.info(`\uD83D\uDDBC\uFE0F Model lacks vision, using OCR via ${ocrProvider}...`);
               const ocrText = await multimodalService.ocrImage(imageInput, ocrProvider);
               messageContent = ocrText ? `[Imagen adjunta \u2014 contenido extra\xEDdo por OCR]
 ${ocrText}
 
 ${messageContent || ""}` : messageContent || "";
               inputType = "image";
-              log78.info(`\uD83D\uDDBC\uFE0F OCR result: ${ocrText.substring(0, 100)}...`);
+              log80.info(`\uD83D\uDDBC\uFE0F OCR result: ${ocrText.substring(0, 100)}...`);
             }
           } catch (imgError) {
-            log78.error(`\u274C Image processing failed: ${imgError.message}`);
+            log80.error(`\u274C Image processing failed: ${imgError.message}`);
             await channelManager.send(message.channel, message.sessionId, {
               content: `\u26A0\uFE0F Error al procesar la imagen: ${imgError.message}`
             });
@@ -478301,7 +478551,7 @@ ${messageContent || ""}` : messageContent || "";
           try {
             const docInput = multimodalService.normalizeDocumentFromChannel(message.channel, message.document);
             const ocrProvider = visionConfig.ocrProvider || "openai";
-            log78.info(`\uD83D\uDCC4 Document detected, extracting text via OCR (${ocrProvider})...`);
+            log80.info(`\uD83D\uDCC4 Document detected, extracting text via OCR (${ocrProvider})...`);
             const docImage = {
               type: docInput.type,
               data: docInput.data,
@@ -478314,16 +478564,16 @@ ${ocrText}
 
 ${messageContent || ""}` : messageContent || "";
             inputType = "document";
-            log78.info(`\uD83D\uDCC4 Document OCR result: ${ocrText.substring(0, 100)}...`);
+            log80.info(`\uD83D\uDCC4 Document OCR result: ${ocrText.substring(0, 100)}...`);
           } catch (docError) {
-            log78.error(`\u274C Document processing failed: ${docError.message}`);
+            log80.error(`\u274C Document processing failed: ${docError.message}`);
             await channelManager.send(message.channel, message.sessionId, {
               content: `\u26A0\uFE0F Error al procesar el documento: ${docError.message}`
             });
           }
         }
       }
-      log78.info(` Content: ${messageContent.substring(0, 150)}${messageContent.length > 150 ? "..." : ""}`);
+      log80.info(` Content: ${messageContent.substring(0, 150)}${messageContent.length > 150 ? "..." : ""}`);
       const { userId } = resolveContext({
         channel: message.channel,
         channelUserId: message.sessionId
@@ -478354,7 +478604,7 @@ ${messageContent || ""}` : messageContent || "";
 ${messageContent}`;
       const messages2 = contentParts ? [{ role: "user", content: [{ type: "text", text: messageContentWithTime }, ...contentParts] }] : [{ role: "user", content: messageContentWithTime }];
       try {
-        log78.info(`\uD83E\uDD16 Routing to agent loop...`);
+        log80.info(`\uD83E\uDD16 Routing to agent loop...`);
         const response = await runner.generate({
           provider: dbProvider,
           messages: messages2,
@@ -478369,28 +478619,28 @@ ${messageContent}`;
             if (step.type === "text" && step.message) {
               const trimmedMessage = (typeof step.message === "string" ? step.message : "").trim();
               if (trimmedMessage) {
-                log78.debug(`[NARRATION] ${trimmedMessage.substring(0, 100)}`);
+                log80.debug(`[NARRATION] ${trimmedMessage.substring(0, 100)}`);
                 try {
                   await channelManager.send(message.channel, routingSessionId, {
                     content: trimmedMessage,
                     type: "progress"
                   });
                 } catch (err) {
-                  log78.warn(`[onStep] Narration send failed: ${err.message}`);
+                  log80.warn(`[onStep] Narration send failed: ${err.message}`);
                 }
               }
               return;
             }
             if (step.type === "tool_call" && step.toolName) {
               const narration = getNarration(step.toolName);
-              log78.debug(`[TOOL] ${step.toolName} \u2192 "${narration}"`);
+              log80.debug(`[TOOL] ${step.toolName} \u2192 "${narration}"`);
               try {
                 await channelManager.send(message.channel, routingSessionId, {
                   content: narration,
                   type: "progress"
                 });
               } catch (err) {
-                log78.warn(`[onStep] Tool narration send failed: ${err.message}`);
+                log80.warn(`[onStep] Tool narration send failed: ${err.message}`);
               }
               return;
             }
@@ -478405,7 +478655,7 @@ ${messageContent}`;
                       type: "progress"
                     });
                   } catch (err) {
-                    log78.warn(`[onStep] Tool result send failed: ${err.message}`);
+                    log80.warn(`[onStep] Tool result send failed: ${err.message}`);
                   }
                 }
               } catch {}
@@ -478415,10 +478665,10 @@ ${messageContent}`;
         });
         const responseContent = response.content?.trim() || "";
         if (!responseContent) {
-          log78.warn(`\uD83D\uDCE4 LLM response: empty \u2014 skipping send`);
+          log80.warn(`\uD83D\uDCE4 LLM response: empty \u2014 skipping send`);
           return;
         }
-        log78.info(`\uD83D\uDCE4 LLM response: ${responseContent.substring(0, 100)}${responseContent.length > 100 ? "..." : ""}`);
+        log80.info(`\uD83D\uDCE4 LLM response: ${responseContent.substring(0, 100)}${responseContent.length > 100 ? "..." : ""}`);
         const shouldSpeak = preferAudioResponse;
         let responseType = "text";
         let ttsProviderUsed = null;
@@ -478426,7 +478676,7 @@ ${messageContent}`;
         if (responseContent) {
           if (shouldSpeak) {
             if (!voiceConfig.ttsProvider) {
-              log78.warn(`\u26A0\uFE0F TTS provider not configured, user requested audio`);
+              log80.warn(`\u26A0\uFE0F TTS provider not configured, user requested audio`);
               await channelManager.send(message.channel, routingSessionId, {
                 content: `${responseContent}
 
@@ -478434,7 +478684,7 @@ ${messageContent}`;
               });
             } else {
               try {
-                log78.info(`\uD83D\uDD0A TTS enabled, synthesizing audio...`);
+                log80.info(`\uD83D\uDD0A TTS enabled, synthesizing audio...`);
                 const audioOutput = await voiceService.speak(responseContent, voiceConfig.ttsProvider, voiceConfig.ttsVoiceId || undefined);
                 ttsProviderUsed = voiceConfig.ttsProvider;
                 ttsMimeType = audioOutput.mimeType;
@@ -478443,17 +478693,17 @@ ${messageContent}`;
                   const channel = channelManager.getChannel(message.channel);
                   if (channel?.sendAudio) {
                     await channel.sendAudio(routingSessionId, audioOutput.data, audioOutput.mimeType);
-                    log78.info(`\u2705 Audio sent to ${routingSessionId}`);
+                    log80.info(`\u2705 Audio sent to ${routingSessionId}`);
                   } else {
-                    log78.warn(`Channel ${message.channel} does not support audio, sending text`);
+                    log80.warn(`Channel ${message.channel} does not support audio, sending text`);
                     await channelManager.send(message.channel, routingSessionId, { content: responseContent });
                   }
                 } catch (audioError) {
-                  log78.error(`\u274C Audio send failed: ${audioError.message}, sending text instead`);
+                  log80.error(`\u274C Audio send failed: ${audioError.message}, sending text instead`);
                   await channelManager.send(message.channel, routingSessionId, { content: responseContent });
                 }
               } catch (ttsError) {
-                log78.error(`\u274C TTS failed: ${ttsError.message}, sending text instead`);
+                log80.error(`\u274C TTS failed: ${ttsError.message}, sending text instead`);
                 await channelManager.send(message.channel, routingSessionId, { content: responseContent });
               }
             }
@@ -478468,10 +478718,10 @@ ${messageContent}`;
           channel: message.channel
         };
         await channelManager.stopTyping(message.channel, routingSessionId);
-        log78.info(`\u2705 Response sent to ${routingSessionId} via ${message.channel}`);
+        log80.info(`\u2705 Response sent to ${routingSessionId} via ${message.channel}`);
       } catch (error54) {
         await channelManager.stopTyping(message.channel, routingSessionId);
-        log78.error(`\u274C Error: ${error54.message} `);
+        log80.error(`\u274C Error: ${error54.message} `);
         await channelManager.send(message.channel, routingSessionId, {
           content: `Error: ${error54.message} `
         });
@@ -478519,9 +478769,9 @@ ${messageContent}`;
       const method = req.method;
       const logRequest = (status, duration3) => {
         if (url2.pathname === "/health" || url2.pathname === "/health/") {
-          log78.debug(`${method} ${url2.pathname} - ${status} (${duration3}ms)`);
+          log80.debug(`${method} ${url2.pathname} - ${status} (${duration3}ms)`);
         } else {
-          log78.info(`${method} ${url2.pathname} - ${status} (${duration3}ms)`);
+          log80.info(`${method} ${url2.pathname} - ${status} (${duration3}ms)`);
         }
       };
       const handleRequest = async () => {
@@ -478599,7 +478849,7 @@ ${messageContent}`;
           if (isDev) {
             const uiDir2 = path30.join(process.cwd(), "packages/hive-ui/dist");
             const indexPath = path30.join(uiDir2, "index.html");
-            if (!existsSync27(indexPath)) {
+            if (!existsSync29(indexPath)) {
               return new Response(`UI build not found. Please run: cd packages/hive-ui && bun run build
 
 ` + "Or use: bun run dev (from root) which builds automatically.", { status: 503, headers: { "Content-Type": "text/plain" } });
@@ -478639,7 +478889,7 @@ ${messageContent}`;
           const uiDirFromHive = path30.join(getHiveDir(), "ui");
           const uiDirFromDist = process.env.HIVE_DIST_DIR ? path30.join(process.env.HIVE_DIST_DIR, "ui") : null;
           const uiDirFromCwd = path30.join(process.cwd(), "packages/hive-ui/dist");
-          const uiDir = uiDirFromEnv || (existsSync27(path30.join(uiDirFromHive, "index.html")) ? uiDirFromHive : uiDirFromDist && existsSync27(path30.join(uiDirFromDist, "index.html")) ? uiDirFromDist : uiDirFromCwd);
+          const uiDir = uiDirFromEnv || (existsSync29(path30.join(uiDirFromHive, "index.html")) ? uiDirFromHive : uiDirFromDist && existsSync29(path30.join(uiDirFromDist, "index.html")) ? uiDirFromDist : uiDirFromCwd);
           let subPath = url2.pathname;
           if (gatewaySetupMode && (subPath === "/" || subPath === "/ui" || subPath === "/ui/")) {
             const _publicBase = process.env.HIVE_PUBLIC_URL?.replace(/\/$/, "") ?? `http://${host === "0.0.0.0" ? "localhost" : host}:${port}`;
@@ -478685,7 +478935,7 @@ ${messageContent}`;
           return Response.redirect(`/ ui${tokenParam} `, 301);
         }
         if (!checkAuth(req, url2)) {
-          log78.warn(`[AUTH] Unauthorized request to ${url2.pathname} from ${req.headers.get("origin")} `);
+          log80.warn(`[AUTH] Unauthorized request to ${url2.pathname} from ${req.headers.get("origin")} `);
           return addCorsHeaders(new Response("Unauthorized", { status: 401 }), req);
         }
         if (url2.pathname === "/api/setup/status" || url2.pathname === "/api/setup/status/") {
@@ -478905,7 +479155,7 @@ ${messageContent}`;
           return await handleApiReload(req, addCorsHeaders, agent);
         }
         if (url2.pathname === "/api/user/channels" && req.method === "POST") {
-          return await handleLinkUserChannel(req, addCorsHeaders, config2, log78);
+          return await handleLinkUserChannel(req, addCorsHeaders, config2, log80);
         }
         if (url2.pathname === "/api/user/channels" && req.method === "GET") {
           return await handleGetUserChannels(req, addCorsHeaders, config2);
@@ -479035,16 +479285,16 @@ ${messageContent}`;
             if (active === undefined) {
               return addCorsHeaders(Response.json({ success: false, error: "Missing active field" }, { status: 400 }), req);
             }
-            log78.info(`[MCP] Toggle connection for ${mcpName}, active=${active}`);
+            log80.info(`[MCP] Toggle connection for ${mcpName}, active=${active}`);
             getDb().query(`UPDATE mcp_servers SET active = ?, enabled = ? WHERE id = ? OR name = ?`).run(active ? 1 : 0, active ? 1 : 0, mcpName, mcpName);
             try {
               const mcp = agent?.getMCPManager() ?? null;
               if (mcp) {
-                log78.info(`[MCP] Manager found, connecting ${mcpName}...`);
+                log80.info(`[MCP] Manager found, connecting ${mcpName}...`);
                 if (active) {
                   const server3 = getDb().query(`SELECT * FROM mcp_servers WHERE id = ? OR name = ?`).get(mcpName, mcpName);
                   if (server3) {
-                    log78.info(`[MCP] Server config: transport=${server3.transport}, url=${server3.url}`);
+                    log80.info(`[MCP] Server config: transport=${server3.transport}, url=${server3.url}`);
                     const mcpServerConfig = {
                       transport: server3.transport,
                       command: server3.command,
@@ -479056,7 +479306,7 @@ ${messageContent}`;
                       try {
                         mcpServerConfig.headers = decryptConfig(server3.headers_encrypted, server3.headers_iv);
                       } catch (e) {
-                        log78.warn(`Failed to decrypt headers for ${mcpName}`);
+                        log80.warn(`Failed to decrypt headers for ${mcpName}`);
                       }
                     }
                     const currentConfig = mcp.config || { servers: {} };
@@ -479066,22 +479316,22 @@ ${messageContent}`;
                       ...currentConfig,
                       servers: newServersConfig
                     });
-                    log78.info(`[MCP] Server registered in MCP Manager`);
+                    log80.info(`[MCP] Server registered in MCP Manager`);
                     const tools = mcp.getServerTools(mcpName) || [];
-                    log78.info(`[MCP] Connected! Tools: ${tools.length}`);
+                    log80.info(`[MCP] Connected! Tools: ${tools.length}`);
                     getDb().query(`UPDATE mcp_servers SET status = ?, tools_count = ? WHERE id = ? OR name = ?`).run("connected", tools.length, mcpName, mcpName);
                   } else {
-                    log78.error(`[MCP] Server not found in DB: ${mcpName}`);
+                    log80.error(`[MCP] Server not found in DB: ${mcpName}`);
                   }
                 } else {
                   await mcp.disconnectServer(mcpName);
                   getDb().query(`UPDATE mcp_servers SET status = ? WHERE id = ? OR name = ?`).run("disconnected", mcpName, mcpName);
                 }
               } else {
-                log78.error(`[MCP] No MCP Manager found`);
+                log80.error(`[MCP] No MCP Manager found`);
               }
             } catch (error54) {
-              log78.error(`[MCP] Failed to connect ${mcpName}: ${error54.message}`);
+              log80.error(`[MCP] Failed to connect ${mcpName}: ${error54.message}`);
             }
             return addCorsHeaders(Response.json({ success: true, active, message: active ? "Servidor MCP conectado" : "Servidor MCP desconectado" }), req);
           }
@@ -479108,7 +479358,7 @@ ${messageContent}`;
                 if (active) {
                   const server3 = getDb().query(`SELECT * FROM mcp_servers WHERE id = ? OR name = ?`).get(mcpName, mcpName);
                   if (server3) {
-                    log78.info(`[MCP] Server config: transport=${server3.transport}, url=${server3.url}`);
+                    log80.info(`[MCP] Server config: transport=${server3.transport}, url=${server3.url}`);
                     const mcpServerConfig = {
                       transport: server3.transport,
                       command: server3.command,
@@ -479120,7 +479370,7 @@ ${messageContent}`;
                       try {
                         mcpServerConfig.headers = decryptConfig(server3.headers_encrypted, server3.headers_iv);
                       } catch (e) {
-                        log78.warn(`Failed to decrypt headers for ${mcpName}`);
+                        log80.warn(`Failed to decrypt headers for ${mcpName}`);
                       }
                     }
                     const currentConfig = mcp.config || { servers: {} };
@@ -479130,12 +479380,12 @@ ${messageContent}`;
                       ...currentConfig,
                       servers: newServersConfig
                     });
-                    log78.info(`[MCP] Server registered in MCP Manager`);
+                    log80.info(`[MCP] Server registered in MCP Manager`);
                     const tools = mcp.getServerTools(mcpName) || [];
-                    log78.info(`[MCP] Connected! Tools: ${tools.length}`);
+                    log80.info(`[MCP] Connected! Tools: ${tools.length}`);
                     getDb().query(`UPDATE mcp_servers SET status = ?, tools_count = ? WHERE id = ? OR name = ?`).run("connected", tools.length, mcpName, mcpName);
                   } else {
-                    log78.error(`[MCP] Server not found in DB: ${mcpName}`);
+                    log80.error(`[MCP] Server not found in DB: ${mcpName}`);
                   }
                 } else {
                   await mcp.disconnectServer(mcpName);
@@ -479143,7 +479393,7 @@ ${messageContent}`;
                 }
               }
             } catch (error54) {
-              log78.error(`[MCP] Failed to connect ${mcpName}: ${error54.message}`);
+              log80.error(`[MCP] Failed to connect ${mcpName}: ${error54.message}`);
             }
             return addCorsHeaders(Response.json({ success: true, active, message: active ? "Servidor MCP conectado" : "Servidor MCP desconectado" }), req);
           }
@@ -479332,12 +479582,12 @@ ${messageContent}`;
         if (response) {
           logRequest(response.status, duration3);
         } else {
-          log78.info(`${method} ${url2.pathname} - 101 Switching Protocols(${duration3}ms)`);
+          log80.info(`${method} ${url2.pathname} - 101 Switching Protocols(${duration3}ms)`);
         }
         return response;
       } catch (error54) {
         const duration3 = Date.now() - start;
-        log78.error(`${method} ${url2.pathname} - Internal Error(${duration3}ms): ${error54.message} `);
+        log80.error(`${method} ${url2.pathname} - Internal Error(${duration3}ms): ${error54.message} `);
         return addCorsHeaders(Response.json({ success: false, error: error54.message, message: "Error interno del servidor" }, { status: 500 }), req);
       }
     },
@@ -479346,17 +479596,17 @@ ${messageContent}`;
         const data = ws.data;
         const isBridge = data.sessionId.startsWith("bridge:");
         if (isBridge) {
-          log78.info(`Bridge events client connected: ${data.sessionId}`);
+          log80.info(`Bridge events client connected: ${data.sessionId}`);
           subscribeBridge(ws);
           ws.send(JSON.stringify({ type: "bridge:connected", sessionId: data.sessionId }));
           return;
         }
         if (data.sessionId.startsWith("meeting:")) {
-          log78.info(`Meeting stream client connected: ${data.sessionId}`);
+          log80.info(`Meeting stream client connected: ${data.sessionId}`);
           ws.send(JSON.stringify({ type: "meeting:connected", sessionId: data.sessionId, meetingSessionId: data.meetingSessionId }));
           return;
         }
-        log78.debug(`WebSocket connected: ${data.sessionId} `);
+        log80.debug(`WebSocket connected: ${data.sessionId} `);
         sessionManager.create(data.sessionId, ws);
         const channel = channelManager?.getChannel("webchat");
         if (channel?.registerConnection)
@@ -479387,7 +479637,7 @@ ${messageContent}`;
             codeBridge: codeBridge.map((cb) => cb.id)
           }));
         } catch (err) {
-          log78.error("Error sending welcome message:", err);
+          log80.error("Error sending welcome message:", err);
         }
       },
       async message(ws, message) {
@@ -479484,7 +479734,7 @@ ${messageContent}`;
           const sourceComponentId = actionData.sourceComponentId ?? "unknown";
           const context = actionData.context ?? {};
           const interactionMsg = `[a2ui:action] surface=${surfaceId} action=${actionName} component=${sourceComponentId}${Object.keys(context).length > 0 ? ` context=${JSON.stringify(context)}` : ""}`;
-          log78.info(`A2UI action forwarded to agent: ${interactionMsg}`);
+          log80.info(`A2UI action forwarded to agent: ${interactionMsg}`);
           const sessionId = data.sessionId;
           ws.send(JSON.stringify({ type: "typing", isTyping: true, sessionId }));
           laneQueue.enqueue(sessionId, async (_task, signal2) => {
@@ -479514,7 +479764,7 @@ ${messageContent}`;
                 onStep: async (step) => {
                   if (signal2.aborted)
                     return;
-                  log78.debug(`[a2ui:action TOOL] ${step.type}: ${step.toolName || ""}`);
+                  log80.debug(`[a2ui:action TOOL] ${step.type}: ${step.toolName || ""}`);
                 }
               });
               ws.send(JSON.stringify({ type: "typing", isTyping: false, sessionId }));
@@ -479525,7 +479775,7 @@ ${messageContent}`;
             } catch (error54) {
               ws.send(JSON.stringify({ type: "typing", isTyping: false, sessionId }));
               ws.send(JSON.stringify({ type: "error", sessionId, error: error54.message }));
-              log78.error(`A2UI action agent error: ${error54.message}`);
+              log80.error(`A2UI action agent error: ${error54.message}`);
             }
           });
           return;
@@ -479546,7 +479796,7 @@ ${messageContent}`;
             if (interactionData && Object.keys(interactionData).length > 0) {
               interactionMsg += `, data=${JSON.stringify(interactionData)}`;
             }
-            log78.info(`Canvas interaction forwarded to agent: ${interactionMsg}`);
+            log80.info(`Canvas interaction forwarded to agent: ${interactionMsg}`);
             const sessionId = data.sessionId;
             ws.send(JSON.stringify({ type: "typing", isTyping: true, sessionId }));
             laneQueue.enqueue(sessionId, async (_task, signal2) => {
@@ -479576,7 +479826,7 @@ ${messageContent}`;
                   onStep: async (step) => {
                     if (signal2.aborted)
                       return;
-                    log78.debug(`[canvas:interact TOOL] ${step.type}: ${step.toolName || ""}`);
+                    log80.debug(`[canvas:interact TOOL] ${step.type}: ${step.toolName || ""}`);
                   }
                 });
                 ws.send(JSON.stringify({ type: "typing", isTyping: false, sessionId }));
@@ -479587,7 +479837,7 @@ ${messageContent}`;
               } catch (error54) {
                 ws.send(JSON.stringify({ type: "typing", isTyping: false, sessionId }));
                 ws.send(JSON.stringify({ type: "error", sessionId, error: error54.message }));
-                log78.error(`Canvas interact agent error: ${error54.message}`);
+                log80.error(`Canvas interact agent error: ${error54.message}`);
               }
             });
           }
@@ -479602,17 +479852,17 @@ ${messageContent}`;
         }
         if (msg.type === "logs_subscribe") {
           logSubscribers.add(data.sessionId);
-          log78.debug(`Session ${data.sessionId} subscribed to logs`);
+          log80.debug(`Session ${data.sessionId} subscribed to logs`);
           return;
         }
         if (msg.type === "logs_unsubscribe") {
           logSubscribers.delete(data.sessionId);
-          log78.debug(`Session ${data.sessionId} unsubscribed from logs`);
+          log80.debug(`Session ${data.sessionId} unsubscribed from logs`);
           return;
         }
         if (msg.type === "stop") {
           const cancelled = laneQueue.cancel(msg.sessionId);
-          log78.info(`[stop] Session ${msg.sessionId} \u2014 cancelled: ${cancelled}`);
+          log80.info(`[stop] Session ${msg.sessionId} \u2014 cancelled: ${cancelled}`);
           ws.send(JSON.stringify({
             type: "typing",
             isTyping: false,
@@ -479629,7 +479879,7 @@ ${messageContent}`;
         }
         let webchatPreferAudio = false;
         if (msg.type === "audio" && msg.audio) {
-          log78.info(`WebChat audio from session ${msg.sessionId}`);
+          log80.info(`WebChat audio from session ${msg.sessionId}`);
           const voiceConfig = voiceService.getChannelVoiceConfig("webchat");
           if (!voiceConfig.voiceEnabled) {
             ws.send(JSON.stringify({
@@ -479656,7 +479906,7 @@ ${messageContent}`;
             const audioInput = { type: "base64", data: msg.audio, mimeType: "audio/webm" };
             const sttProvider = voiceConfig.sttProvider || "groq-whisper";
             const messageContent = await voiceService.transcribe(audioInput, sttProvider);
-            log78.info(`\uD83D\uDCDD Transcribed: ${messageContent.substring(0, 100)}...`);
+            log80.info(`\uD83D\uDCDD Transcribed: ${messageContent.substring(0, 100)}...`);
             webchatPreferAudio = true;
             ws.send(JSON.stringify({
               type: "message",
@@ -479677,7 +479927,7 @@ ${messageContent}`;
               try {
                 const unifiedSessionId = msg.sessionId;
                 const messages2 = [{ role: "user", content: messageContent }];
-                log78.info(`Generating response for session ${unifiedSessionId}...`);
+                log80.info(`Generating response for session ${unifiedSessionId}...`);
                 const { userId } = resolveContext({
                   channel: "webchat",
                   channelUserId: msg.sessionId
@@ -479747,7 +479997,7 @@ ${messageContent}`;
                   }
                 });
                 const content = streamedContent || response.content?.trim() || "";
-                log78.info(`Response sent to session ${unifiedSessionId} (${content.length} chars)`);
+                log80.info(`Response sent to session ${unifiedSessionId} (${content.length} chars)`);
                 const voiceCfg = voiceService.getChannelVoiceConfig("webchat");
                 const shouldSpeak = webchatPreferAudio;
                 let responseType = "text";
@@ -479768,13 +480018,13 @@ ${messageContent}`;
                       }));
                     } else {
                       try {
-                        log78.info(`\uD83D\uDD0A TTS enabled, synthesizing audio for WebChat...`);
+                        log80.info(`\uD83D\uDD0A TTS enabled, synthesizing audio for WebChat...`);
                         const audioOutput = await voiceService.speak(content, voiceCfg.ttsProvider, voiceCfg.ttsVoiceId || undefined);
                         ttsProviderUsed = voiceCfg.ttsProvider;
                         ttsMimeType = audioOutput.mimeType;
                         responseType = "audio";
                         const base64Audio = audioOutput.data.toString("base64");
-                        log78.info(`Audio generated: ${base64Audio.length} bytes, mimeType: ${audioOutput.mimeType}`);
+                        log80.info(`Audio generated: ${base64Audio.length} bytes, mimeType: ${audioOutput.mimeType}`);
                         ws.send(JSON.stringify({
                           type: "message",
                           sessionId: unifiedSessionId,
@@ -479784,7 +480034,7 @@ ${messageContent}`;
                           isStep: false
                         }));
                       } catch (ttsError) {
-                        log78.error(`TTS failed: ${ttsError.message}), sending text instead`);
+                        log80.error(`TTS failed: ${ttsError.message}), sending text instead`);
                         ws.send(JSON.stringify({ type: "message", sessionId: unifiedSessionId, content, isStep: false }));
                       }
                     }
@@ -479793,10 +480043,10 @@ ${messageContent}`;
                   }
                 } else if (alreadyStreamed && shouldSpeak && voiceCfg.ttsProvider) {
                   try {
-                    log78.info(`\uD83D\uDD0A TTS enabled, synthesizing audio after streaming...`);
+                    log80.info(`\uD83D\uDD0A TTS enabled, synthesizing audio after streaming...`);
                     const audioOutput = await voiceService.speak(content, voiceCfg.ttsProvider, voiceCfg.ttsVoiceId || undefined);
                     const base64Audio = audioOutput.data.toString("base64");
-                    log78.info(`Audio generated after streaming: ${base64Audio.length} bytes`);
+                    log80.info(`Audio generated after streaming: ${base64Audio.length} bytes`);
                     ws.send(JSON.stringify({
                       type: "message",
                       sessionId: unifiedSessionId,
@@ -479806,7 +480056,7 @@ ${messageContent}`;
                       isStep: false
                     }));
                   } catch (ttsError) {
-                    log78.error(`TTS after streaming failed: ${ttsError.message}), skipping audio`);
+                    log80.error(`TTS after streaming failed: ${ttsError.message}), skipping audio`);
                   }
                 }
               } catch (error54) {
@@ -479816,7 +480066,7 @@ ${messageContent}`;
                   sessionId: msg.sessionId,
                   error: error54.message
                 }));
-                log78.error(`Error for session ${msg.sessionId}: ${error54.message}`);
+                log80.error(`Error for session ${msg.sessionId}: ${error54.message}`);
               }
             });
           } catch (error54) {
@@ -479834,7 +480084,7 @@ ${messageContent}`;
           return;
         }
         if (msg.type === "message" && msg.content) {
-          log78.info(`WebChat message from session ${msg.sessionId}: ${msg.content.substring(0, 100)}`);
+          log80.info(`WebChat message from session ${msg.sessionId}: ${msg.content.substring(0, 100)}`);
           ws.send(JSON.stringify({
             type: "typing",
             isTyping: true,
@@ -479852,7 +480102,7 @@ ${messageContent}`;
               let contentParts = undefined;
               const visionConfig = multimodalService.getChannelVisionConfig("webchat");
               if (msg.image || msg.document) {
-                log78.info(`\uD83D\uDDBC\uFE0F Multimodal content detected from WebChat session ${unifiedSessionId}`);
+                log80.info(`\uD83D\uDDBC\uFE0F Multimodal content detected from WebChat session ${unifiedSessionId}`);
                 if (msg.image) {
                   try {
                     const imageInput = {
@@ -479866,25 +480116,25 @@ ${messageContent}`;
                     const modelHasVision = activeModelId && activeProviderId ? multimodalService.modelSupportsVision(activeProviderId, activeModelId) : false;
                     if (visionConfig.visionEnabled && modelHasVision) {
                       contentParts = await multimodalService.processImage(imageInput, visionConfig.visionModelId || undefined);
-                      log78.info(`\uD83D\uDDBC\uFE0F Image sent as vision ContentParts (model supports vision)`);
+                      log80.info(`\uD83D\uDDBC\uFE0F Image sent as vision ContentParts (model supports vision)`);
                     } else {
                       const ocrProvider = visionConfig.ocrProvider || (["openai", "gemini", "anthropic"].includes(dbProvider) ? dbProvider : "openai");
-                      log78.info(`\uD83D\uDDBC\uFE0F Model lacks vision or vision disabled, using OCR via ${ocrProvider}...`);
+                      log80.info(`\uD83D\uDDBC\uFE0F Model lacks vision or vision disabled, using OCR via ${ocrProvider}...`);
                       const ocrText = await multimodalService.ocrImage(imageInput, ocrProvider);
                       finalMessageContent = ocrText ? `[Imagen adjunta \u2014 contenido extra\xEDdo por OCR]
 ${ocrText}
 
 ${finalMessageContent || ""}` : finalMessageContent || "";
-                      log78.info(`\uD83D\uDDBC\uFE0F OCR result: ${ocrText.substring(0, 100)}...`);
+                      log80.info(`\uD83D\uDDBC\uFE0F OCR result: ${ocrText.substring(0, 100)}...`);
                     }
                   } catch (imgError) {
-                    log78.error(`\u274C Image processing failed: ${imgError.message}`);
+                    log80.error(`\u274C Image processing failed: ${imgError.message}`);
                   }
                 }
                 if (msg.document) {
                   try {
                     const ocrProvider = visionConfig.ocrProvider || (["openai", "gemini", "anthropic"].includes(dbProvider) ? dbProvider : "openai");
-                    log78.info(`\uD83D\uDCC4 Document detected from WebChat, extracting text via OCR (${ocrProvider})...`);
+                    log80.info(`\uD83D\uDCC4 Document detected from WebChat, extracting text via OCR (${ocrProvider})...`);
                     const docImage = {
                       type: "base64",
                       data: msg.document.base64,
@@ -479896,14 +480146,14 @@ ${finalMessageContent || ""}` : finalMessageContent || "";
 ${ocrText}
 
 ${finalMessageContent || ""}` : finalMessageContent || "";
-                    log78.info(`\uD83D\uDCC4 Document OCR result: ${ocrText.substring(0, 100)}...`);
+                    log80.info(`\uD83D\uDCC4 Document OCR result: ${ocrText.substring(0, 100)}...`);
                   } catch (docError) {
-                    log78.error(`\u274C Document processing failed: ${docError.message}`);
+                    log80.error(`\u274C Document processing failed: ${docError.message}`);
                   }
                 }
               }
               const messages2 = contentParts ? [{ role: "user", content: contentParts }] : [{ role: "user", content: finalMessageContent }];
-              log78.info(`Generating response for session ${unifiedSessionId} (multimodal: ${!!(msg.image || msg.document)})...`);
+              log80.info(`Generating response for session ${unifiedSessionId} (multimodal: ${!!(msg.image || msg.document)})...`);
               const { userId } = resolveContext({
                 channel: "webchat",
                 channelUserId: msg.sessionId
@@ -479974,7 +480224,7 @@ ${finalMessageContent || ""}` : finalMessageContent || "";
                 }
               });
               const content = streamedContent || response.content?.trim() || "";
-              log78.info(`Response sent to session ${unifiedSessionId} (${content.length} chars)`);
+              log80.info(`Response sent to session ${unifiedSessionId} (${content.length} chars)`);
               const voiceConfig = voiceService.getChannelVoiceConfig("webchat");
               const shouldSpeak = webchatPreferAudio;
               let responseType = "text";
@@ -479995,7 +480245,7 @@ ${finalMessageContent || ""}` : finalMessageContent || "";
                     }));
                   } else {
                     try {
-                      log78.info(`\uD83D\uDD0A TTS enabled, synthesizing audio for WebChat...`);
+                      log80.info(`\uD83D\uDD0A TTS enabled, synthesizing audio for WebChat...`);
                       const audioOutput = await voiceService.speak(content, voiceConfig.ttsProvider, voiceConfig.ttsVoiceId || undefined);
                       ttsProviderUsed = voiceConfig.ttsProvider;
                       ttsMimeType = audioOutput.mimeType;
@@ -480010,7 +480260,7 @@ ${finalMessageContent || ""}` : finalMessageContent || "";
                         isStep: false
                       }));
                     } catch (ttsError) {
-                      log78.error(`TTS failed: ${ttsError.message}), sending text instead`);
+                      log80.error(`TTS failed: ${ttsError.message}), sending text instead`);
                       ws.send(JSON.stringify({ type: "message", sessionId: unifiedSessionId, content, isStep: false }));
                     }
                   }
@@ -480019,10 +480269,10 @@ ${finalMessageContent || ""}` : finalMessageContent || "";
                 }
               } else if (alreadyStreamed && shouldSpeak && voiceConfig.ttsProvider) {
                 try {
-                  log78.info(`\uD83D\uDD0A TTS enabled, synthesizing audio after streaming...`);
+                  log80.info(`\uD83D\uDD0A TTS enabled, synthesizing audio after streaming...`);
                   const audioOutput = await voiceService.speak(content, voiceConfig.ttsProvider, voiceConfig.ttsVoiceId || undefined);
                   const base64Audio = audioOutput.data.toString("base64");
-                  log78.info(`Audio generated after streaming: ${base64Audio.length} bytes`);
+                  log80.info(`Audio generated after streaming: ${base64Audio.length} bytes`);
                   ws.send(JSON.stringify({
                     type: "message",
                     sessionId: unifiedSessionId,
@@ -480032,7 +480282,7 @@ ${finalMessageContent || ""}` : finalMessageContent || "";
                     isStep: false
                   }));
                 } catch (ttsError) {
-                  log78.error(`TTS after streaming failed: ${ttsError.message}), skipping audio`);
+                  log80.error(`TTS after streaming failed: ${ttsError.message}), skipping audio`);
                 }
               }
             } catch (error54) {
@@ -480043,7 +480293,7 @@ ${finalMessageContent || ""}` : finalMessageContent || "";
                 sessionId: unifiedSessionId,
                 error: error54.message
               }));
-              log78.error(`Error for session ${unifiedSessionId}: ${error54.message}`);
+              log80.error(`Error for session ${unifiedSessionId}: ${error54.message}`);
             }
           });
           return;
@@ -480062,10 +480312,10 @@ ${finalMessageContent || ""}` : finalMessageContent || "";
           return;
         }
         if (data.sessionId.startsWith("meeting:")) {
-          log78.info(`Meeting stream client disconnected: ${data.sessionId}`);
+          log80.info(`Meeting stream client disconnected: ${data.sessionId}`);
           return;
         }
-        log78.debug(`WebSocket disconnected: ${data.sessionId}`);
+        log80.debug(`WebSocket disconnected: ${data.sessionId}`);
         logSubscribers.delete(data.sessionId);
         sessionManager.delete(data.sessionId);
         laneQueue.cancel(data.sessionId);
@@ -480098,28 +480348,28 @@ ${finalMessageContent || ""}` : finalMessageContent || "";
       }
     }
   });
-  log78.info(`Gateway started successfully`);
+  log80.info(`Gateway started successfully`);
   const isGatewayChild = process.env.HIVE_GATEWAY_CHILD === "1";
   if (isDev) {
     const devUrl = gatewaySetupMode ? `http://localhost:${port}/setup` : `http://localhost:${port}`;
-    log78.info(`[gateway] UI:        ${devUrl}`);
-    log78.info(`[gateway] API:       http://${host}:${port}`);
-    log78.info(`[gateway] WebSocket: ws://${host}:${port}/ws`);
-    log78.info(`[gateway] Canvas:    ws://${host}:${port}/canvas`);
-    log78.info(`[gateway] Modo:     desarrollo`);
+    log80.info(`[gateway] UI:        ${devUrl}`);
+    log80.info(`[gateway] API:       http://${host}:${port}`);
+    log80.info(`[gateway] WebSocket: ws://${host}:${port}/ws`);
+    log80.info(`[gateway] Canvas:    ws://${host}:${port}/canvas`);
+    log80.info(`[gateway] Modo:     desarrollo`);
     if (!isGatewayChild) {
-      log78.info(gatewaySetupMode ? `\uD83C\uDF89 Primer arranque \u2014 abriendo setup...` : `\uD83D\uDC1D Administra tu Hive aqu\xED: ${devUrl}`);
+      log80.info(gatewaySetupMode ? `\uD83C\uDF89 Primer arranque \u2014 abriendo setup...` : `\uD83D\uDC1D Administra tu Hive aqu\xED: ${devUrl}`);
     }
   } else {
     const isSetupMode2 = gatewaySetupMode;
     const baseUrl = process.env.HIVE_PUBLIC_URL?.replace(/\/$/, "") ?? `http://${host}:${port}`;
     const uiUrl = isSetupMode2 ? `${baseUrl}/setup` : `${baseUrl}/ui`;
-    log78.info(`[gateway] UI:        ${uiUrl}`);
-    log78.info(`[gateway] API:       http://${host}:${port}`);
-    log78.info(`[gateway] WebSocket: ws://${host}:${port}/ws`);
-    log78.info(`[gateway] Canvas:    ws://${host}:${port}/canvas`);
+    log80.info(`[gateway] UI:        ${uiUrl}`);
+    log80.info(`[gateway] API:       http://${host}:${port}`);
+    log80.info(`[gateway] WebSocket: ws://${host}:${port}/ws`);
+    log80.info(`[gateway] Canvas:    ws://${host}:${port}/canvas`);
     if (!process.env.NO_BROWSER) {
-      log78.info(isSetupMode2 ? `\uD83C\uDF89 Primer arranque \u2014 abriendo wizard de configuraci\xF3n...` : `\uD83D\uDC1D Administra tu Hive aqu\xED: ${uiUrl}`);
+      log80.info(isSetupMode2 ? `\uD83C\uDF89 Primer arranque \u2014 abriendo wizard de configuraci\xF3n...` : `\uD83D\uDC1D Administra tu Hive aqu\xED: ${uiUrl}`);
       try {
         const platform2 = process.platform;
         let shellCmd;
@@ -480139,59 +480389,59 @@ ${finalMessageContent || ""}` : finalMessageContent || "";
         });
         proc.unref();
       } catch (err) {
-        log78.warn(`Could not open browser: ${err.message}`);
+        log80.warn(`Could not open browser: ${err.message}`);
       }
     }
   }
   if (!gatewaySetupMode)
-    log78.info(`Channels: ${channelManager.listChannels().map((c) => c.name).join(", ") || "none"}`);
+    log80.info(`Channels: ${channelManager.listChannels().map((c) => c.name).join(", ") || "none"}`);
   process.on("SIGTERM", async () => {
-    log78.info("Received SIGTERM, shutting down gracefully...");
+    log80.info("Received SIGTERM, shutting down gracefully...");
     watchers.forEach((close) => close());
     const mcp = agent?.getMCPManager();
     if (mcp) {
-      log78.info("Disconnecting MCP servers...");
+      log80.info("Disconnecting MCP servers...");
       await mcp.disconnectAll().catch(() => {});
     }
     if (channelManager) {
-      log78.info("Stopping channels...");
+      log80.info("Stopping channels...");
       await channelManager.stopAll();
     }
     try {
       const mod = await Promise.resolve().then(() => (init_browser_service(), exports_browser_service));
       mod.CDPClient.closeAll();
-      log78.info("Browser processes cleaned up");
+      log80.info("Browser processes cleaned up");
     } catch {}
     try {
       canvasManager.clearAll();
-      log78.info("Canvas sessions cleaned up");
+      log80.info("Canvas sessions cleaned up");
     } catch {}
     try {
       const { stopMCPHotReload: stopMCPHotReload2 } = await Promise.resolve().then(() => (init_hot_reload(), exports_hot_reload));
       stopMCPHotReload2();
-      log78.info("MCP hot-reload stopped");
+      log80.info("MCP hot-reload stopped");
     } catch {}
     server.stop();
     try {
       unlinkSync4(pidFile);
     } catch {}
-    log78.info("Gateway shutdown complete");
+    log80.info("Gateway shutdown complete");
     process.exit(0);
   });
   process.on("SIGHUP", async () => {
-    log78.info("Received SIGHUP, reloading configuration...");
+    log80.info("Received SIGHUP, reloading configuration...");
     try {
       const newConfig = await loadConfig();
       await agent.updateConfig(newConfig);
       await agent.reload();
-      log78.info("Configuration reloaded successfully");
+      log80.info("Configuration reloaded successfully");
     } catch (error54) {
-      log78.error(`Failed to reload configuration: ${error54.message}`);
+      log80.error(`Failed to reload configuration: ${error54.message}`);
     }
   });
 }
 var _pkgVersion, logSubscribers;
-var init_server = __esm(() => {
+var init_server2 = __esm(() => {
   init_loader();
   init_logger();
   init_session();
@@ -480242,7 +480492,7 @@ var init_server = __esm(() => {
   _pkgVersion = (() => {
     try {
       const pkgPath = path30.join(import.meta.dir, "../../../package.json");
-      return JSON.parse(readFileSync13(pkgPath, "utf-8")).version;
+      return JSON.parse(readFileSync14(pkgPath, "utf-8")).version;
     } catch {
       return "0.0.27";
     }
@@ -480253,7 +480503,7 @@ var init_server = __esm(() => {
 // packages/core/src/gateway/index.ts
 var init_gateway = __esm(() => {
   init_loader();
-  init_server();
+  init_server2();
   init_logger();
 });
 
@@ -481683,7 +481933,7 @@ var init_circuit_breaker = __esm(() => {
   circuitBreakerRegistry = new CircuitBreakerRegistry;
 });
 // packages/core/src/plugins/loader.ts
-import { mkdirSync as mkdirSync17, readdirSync as readdirSync5, existsSync as existsSync28 } from "fs";
+import { mkdirSync as mkdirSync18, readdirSync as readdirSync7, existsSync as existsSync30 } from "fs";
 import * as path31 from "path";
 
 class PluginLoader {
@@ -481697,19 +481947,19 @@ class PluginLoader {
   log = logger.child("plugins");
   constructor(options2) {
     this.options = options2;
-    if (!existsSync28(options2.pluginDir)) {
-      mkdirSync17(options2.pluginDir, { recursive: true });
+    if (!existsSync30(options2.pluginDir)) {
+      mkdirSync18(options2.pluginDir, { recursive: true });
     }
   }
   async discover() {
     const pluginDir = this.options.pluginDir;
     const discovered = [];
     try {
-      const entries = readdirSync5(pluginDir, { withFileTypes: true });
+      const entries = readdirSync7(pluginDir, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isDirectory()) {
           const manifestPath = path31.join(pluginDir, entry.name, "manifest.json");
-          if (existsSync28(manifestPath)) {
+          if (existsSync30(manifestPath)) {
             discovered.push(entry.name);
           }
         }
@@ -482004,7 +482254,7 @@ var init_src3 = __esm(() => {
   init_tools();
   init_retry();
   init_gateway();
-  init_server();
+  init_server2();
   init_service();
   init_agent_loop();
   init_context_compiler();
@@ -482086,7 +482336,7 @@ var init_types6 = __esm(() => {
 
 // packages/cli/src/adapters/config.ts
 import * as path32 from "path";
-import { existsSync as existsSync29, readFileSync as readFileSync14 } from "fs";
+import { existsSync as existsSync31, readFileSync as readFileSync15 } from "fs";
 function getHiveDir2(customDir) {
   if (customDir) {
     return path32.resolve(customDir);
@@ -482114,11 +482364,11 @@ function getDefaultPaths(hiveDir) {
 }
 function loadEnvFile(envPath) {
   const filePath = envPath || path32.join(process.cwd(), ".env");
-  if (!existsSync29(filePath)) {
+  if (!existsSync31(filePath)) {
     return {};
   }
   try {
-    const content = readFileSync14(filePath, "utf-8");
+    const content = readFileSync15(filePath, "utf-8");
     const env2 = {};
     for (const line of content.split(`
 `)) {
@@ -482186,7 +482436,7 @@ function getDistDir() {
     return dir;
   }
   const distPath = path32.join(dir, "dist");
-  if (existsSync29(distPath)) {
+  if (existsSync31(distPath)) {
     return distPath;
   }
   return null;
@@ -482208,7 +482458,7 @@ __export(exports_docker, {
 });
 import { spawn as spawn3, execSync } from "child_process";
 import * as path33 from "path";
-import { existsSync as existsSync30 } from "fs";
+import { existsSync as existsSync32 } from "fs";
 
 class DockerAdapter {
   type = "docker";
@@ -482228,7 +482478,7 @@ class DockerAdapter {
       path33.join(process.env.HOME || "", ".hive", "docker-compose.yml")
     ];
     for (const composePath of standardPaths) {
-      if (existsSync30(composePath)) {
+      if (existsSync32(composePath)) {
         return composePath;
       }
     }
@@ -482238,7 +482488,7 @@ class DockerAdapter {
     try {
       execSync("docker --version", { stdio: "ignore" });
       execSync("docker compose version", { stdio: "ignore" });
-      if (!existsSync30(this.composeFile)) {
+      if (!existsSync32(this.composeFile)) {
         return false;
       }
       try {
@@ -482369,7 +482619,7 @@ class DockerAdapter {
     } catch {
       errors6.push("Docker Compose is not installed");
     }
-    if (!existsSync30(this.composeFile)) {
+    if (!existsSync32(this.composeFile)) {
       errors6.push(`docker-compose.yml not found at ${this.composeFile}`);
     } else {
       info3.push(`Compose file: ${this.composeFile}`);
@@ -482409,7 +482659,7 @@ var init_docker = __esm(() => {
 // packages/cli/src/adapters/bun-global.ts
 import { spawn as spawn4, execSync as execSync2 } from "child_process";
 import * as path34 from "path";
-import { existsSync as existsSync31, readFileSync as readFileSync15, unlinkSync as unlinkSync5 } from "fs";
+import { existsSync as existsSync33, readFileSync as readFileSync16, unlinkSync as unlinkSync5 } from "fs";
 
 class BunGlobalAdapter {
   type = "bun-global";
@@ -482429,7 +482679,7 @@ class BunGlobalAdapter {
           stdio: ["ignore", "pipe", "ignore"]
         });
         const hivePath = output.trim();
-        if (hivePath && existsSync31(hivePath)) {
+        if (hivePath && existsSync33(hivePath)) {
           return true;
         }
       } catch {
@@ -482457,13 +482707,13 @@ class BunGlobalAdapter {
       }).trim();
       const distDir = path34.dirname(hivePath);
       const potentialUiDir = path34.join(distDir, "ui");
-      if (existsSync31(potentialUiDir)) {
+      if (existsSync33(potentialUiDir)) {
         uiDir = potentialUiDir;
       }
     } catch {}
     if (!uiDir) {
       const cwdUiDir = path34.join(process.cwd(), "packages/hive-ui/dist");
-      if (existsSync31(cwdUiDir)) {
+      if (existsSync33(cwdUiDir)) {
         uiDir = cwdUiDir;
       }
     }
@@ -482514,8 +482764,8 @@ class BunGlobalAdapter {
   }
   async stop() {
     try {
-      if (existsSync31(this.pidFile)) {
-        const pid = parseInt(readFileSync15(this.pidFile, "utf-8").trim(), 10);
+      if (existsSync33(this.pidFile)) {
+        const pid = parseInt(readFileSync16(this.pidFile, "utf-8").trim(), 10);
         if (!isNaN(pid)) {
           try {
             process.kill(pid, "SIGTERM");
@@ -482547,8 +482797,8 @@ class BunGlobalAdapter {
   }
   async isRunning() {
     try {
-      if (existsSync31(this.pidFile)) {
-        const pid = parseInt(readFileSync15(this.pidFile, "utf-8").trim(), 10);
+      if (existsSync33(this.pidFile)) {
+        const pid = parseInt(readFileSync16(this.pidFile, "utf-8").trim(), 10);
         if (!isNaN(pid)) {
           try {
             process.kill(pid, 0);
@@ -482569,8 +482819,8 @@ class BunGlobalAdapter {
   }
   async getPid() {
     try {
-      if (existsSync31(this.pidFile)) {
-        const pid = parseInt(readFileSync15(this.pidFile, "utf-8").trim(), 10);
+      if (existsSync33(this.pidFile)) {
+        const pid = parseInt(readFileSync16(this.pidFile, "utf-8").trim(), 10);
         if (!isNaN(pid) && pid > 0) {
           try {
             process.kill(pid, 0);
@@ -482611,11 +482861,11 @@ class BunGlobalAdapter {
         encoding: "utf-8",
         stdio: ["ignore", "pipe", "ignore"]
       }).trim();
-      if (hivePath && existsSync31(hivePath)) {
+      if (hivePath && existsSync33(hivePath)) {
         info3.push(`Hive binary: ${hivePath}`);
         const distDir = path34.dirname(hivePath);
         const uiDir = path34.join(distDir, "ui");
-        if (existsSync31(uiDir)) {
+        if (existsSync33(uiDir)) {
           info3.push(`UI directory: ${uiDir}`);
         } else {
           warnings.push("UI directory not found - may use embedded UI");
@@ -482626,7 +482876,7 @@ class BunGlobalAdapter {
     } catch {
       errors6.push("Hive is not installed globally (try: bun install -g @johpaz/hive-agents)");
     }
-    if (existsSync31(this.hiveDir)) {
+    if (existsSync33(this.hiveDir)) {
       info3.push(`Hive home: ${this.hiveDir}`);
     } else {
       warnings.push(`Hive home directory does not exist: ${this.hiveDir}`);
@@ -482668,7 +482918,7 @@ var init_bun_global = __esm(() => {
 // packages/cli/src/adapters/binary.ts
 import { spawn as spawn5, execSync as execSync3 } from "child_process";
 import * as path35 from "path";
-import { existsSync as existsSync32, readFileSync as readFileSync16, unlinkSync as unlinkSync6 } from "fs";
+import { existsSync as existsSync34, readFileSync as readFileSync17, unlinkSync as unlinkSync6 } from "fs";
 
 class BinaryAdapter {
   type = "binary";
@@ -482680,7 +482930,7 @@ class BinaryAdapter {
     this.hiveDir = options2?.hiveDir || getHiveDir2();
     this.pidFile = path35.join(this.hiveDir, "gateway.pid");
     this.binaryPath = options2?.binaryPath || this.findBinary();
-    this.isDockerContainer = process.env.HIVE_UI_DIR === "/app/ui" || process.env.HIVE_HOST === "0.0.0.0" || existsSync32("/.dockerenv");
+    this.isDockerContainer = process.env.HIVE_UI_DIR === "/app/ui" || process.env.HIVE_HOST === "0.0.0.0" || existsSync34("/.dockerenv");
   }
   get name() {
     return this.isDockerContainer ? "Docker Container" : "Standalone Binary";
@@ -482691,15 +482941,15 @@ class BinaryAdapter {
       const dir = path35.dirname(scriptPath);
       if (path35.basename(dir) === "dist") {
         const binaryInDist = path35.join(dir, "hive");
-        if (existsSync32(binaryInDist)) {
+        if (existsSync34(binaryInDist)) {
           return binaryInDist;
         }
         const binaryWindows = path35.join(dir, "hive.exe");
-        if (existsSync32(binaryWindows)) {
+        if (existsSync34(binaryWindows)) {
           return binaryWindows;
         }
       }
-      if (existsSync32(scriptPath) && !scriptPath.endsWith(".ts")) {
+      if (existsSync34(scriptPath) && !scriptPath.endsWith(".ts")) {
         return scriptPath;
       }
     }
@@ -482712,7 +482962,7 @@ class BinaryAdapter {
       path35.join(process.env.HOME || "", ".bun", "bin", "hive")
     ];
     for (const binaryPath of commonPaths) {
-      if (existsSync32(binaryPath)) {
+      if (existsSync34(binaryPath)) {
         return binaryPath;
       }
     }
@@ -482726,7 +482976,7 @@ class BinaryAdapter {
     if (scriptPath.endsWith(".ts")) {
       return false;
     }
-    if (existsSync32(this.binaryPath)) {
+    if (existsSync34(this.binaryPath)) {
       return true;
     }
     try {
@@ -482738,7 +482988,7 @@ class BinaryAdapter {
     const distDir = getDistDir();
     if (distDir) {
       const uiDir = path35.join(distDir, "ui");
-      if (existsSync32(uiDir)) {
+      if (existsSync34(uiDir)) {
         return true;
       }
     }
@@ -482754,7 +483004,7 @@ class BinaryAdapter {
       const distDir = getDistDir();
       if (distDir) {
         const uiDir = path35.join(distDir, "ui");
-        if (existsSync32(uiDir)) {
+        if (existsSync34(uiDir)) {
           paths.uiDir = uiDir;
         }
       }
@@ -482821,8 +483071,8 @@ class BinaryAdapter {
   }
   async stop() {
     try {
-      if (existsSync32(this.pidFile)) {
-        const pid = parseInt(readFileSync16(this.pidFile, "utf-8").trim(), 10);
+      if (existsSync34(this.pidFile)) {
+        const pid = parseInt(readFileSync17(this.pidFile, "utf-8").trim(), 10);
         if (!isNaN(pid)) {
           try {
             process.kill(pid, "SIGTERM");
@@ -482855,8 +483105,8 @@ class BinaryAdapter {
   }
   async isRunning() {
     try {
-      if (existsSync32(this.pidFile)) {
-        const pid = parseInt(readFileSync16(this.pidFile, "utf-8").trim(), 10);
+      if (existsSync34(this.pidFile)) {
+        const pid = parseInt(readFileSync17(this.pidFile, "utf-8").trim(), 10);
         if (!isNaN(pid)) {
           try {
             process.kill(pid, 0);
@@ -482877,8 +483127,8 @@ class BinaryAdapter {
   }
   async getPid() {
     try {
-      if (existsSync32(this.pidFile)) {
-        const pid = parseInt(readFileSync16(this.pidFile, "utf-8").trim(), 10);
+      if (existsSync34(this.pidFile)) {
+        const pid = parseInt(readFileSync17(this.pidFile, "utf-8").trim(), 10);
         if (!isNaN(pid) && pid > 0) {
           try {
             process.kill(pid, 0);
@@ -482910,7 +483160,7 @@ class BinaryAdapter {
     const errors6 = [];
     const warnings = [];
     const info3 = [];
-    if (existsSync32(this.binaryPath)) {
+    if (existsSync34(this.binaryPath)) {
       info3.push(`Binary: ${this.binaryPath}`);
       try {
         const stat3 = await import("fs/promises").then((m2) => m2.stat(this.binaryPath));
@@ -482933,13 +483183,13 @@ class BinaryAdapter {
     const distDir = getDistDir();
     if (distDir) {
       const uiDir = path35.join(distDir, "ui");
-      if (existsSync32(uiDir)) {
+      if (existsSync34(uiDir)) {
         info3.push(`UI directory: ${uiDir}`);
       } else if (!hasEmbeddedUI) {
         warnings.push("UI directory not found and no embedded UI");
       }
     }
-    if (existsSync32(this.hiveDir)) {
+    if (existsSync34(this.hiveDir)) {
       info3.push(`Hive home: ${this.hiveDir}`);
     } else {
       warnings.push(`Hive home directory does not exist: ${this.hiveDir}`);
@@ -482957,7 +483207,7 @@ class BinaryAdapter {
     } else {
       warnings.push("Hive Gateway is not running");
     }
-    if (process.platform !== "win32" && existsSync32(this.binaryPath)) {
+    if (process.platform !== "win32" && existsSync34(this.binaryPath)) {
       try {
         execSync3(`test -x "${this.binaryPath}"`, { stdio: "ignore" });
         info3.push("Binary is executable");
@@ -483659,7 +483909,7 @@ __export(exports_gateway, {
   resetAdapter: () => resetAdapter,
   reload: () => reload
 });
-import { existsSync as existsSync33, mkdirSync as mkdirSync18, writeFileSync as writeFileSync12, readFileSync as readFileSync17, unlinkSync as unlinkSync7, openSync } from "fs";
+import { existsSync as existsSync35, mkdirSync as mkdirSync19, writeFileSync as writeFileSync12, readFileSync as readFileSync18, unlinkSync as unlinkSync7, openSync } from "fs";
 import * as path36 from "path";
 import { spawn as spawn6 } from "child_process";
 async function getAdapter() {
@@ -483702,8 +483952,8 @@ async function getPidFile() {
 }
 function ensureLogDir() {
   const logDir = path36.dirname(getLogFile());
-  if (!existsSync33(logDir)) {
-    mkdirSync18(logDir, { recursive: true });
+  if (!existsSync35(logDir)) {
+    mkdirSync19(logDir, { recursive: true });
   }
 }
 function openBrowser(url2) {
@@ -483735,7 +483985,7 @@ function openBrowser(url2) {
 async function isSetupMode2() {
   const hiveDir = getHiveDir();
   const dbPath = path36.join(hiveDir, "data", "hive.db");
-  return !existsSync33(dbPath);
+  return !existsSync35(dbPath);
 }
 async function isRunning2() {
   try {
@@ -483746,9 +483996,9 @@ async function isRunning2() {
     }
   } catch {}
   const pidFile = await getPidFile();
-  if (!existsSync33(pidFile))
+  if (!existsSync35(pidFile))
     return false;
-  const pid = parseInt(readFileSync17(pidFile, "utf-8").trim(), 10);
+  const pid = parseInt(readFileSync18(pidFile, "utf-8").trim(), 10);
   if (isNaN(pid))
     return false;
   try {
@@ -483810,7 +484060,7 @@ async function start(flags3) {
  \u2551   \u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2551 \u255A\u2588\u2588\u2588\u2588\u2554\u255D \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557             \u2551
  \u2551   \u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u2550\u2550\u255D  \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D             \u2551
  \u2551                                            \u2551
- \u2551   Personal Swarm AI Gateway \u2014 v0.0.30       \u2551
+ \u2551   Personal Swarm AI Gateway \u2014 v0.0.32       \u2551
  \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D
 
 \uD83D\uDCE6 Installation: ${adapter.name}
@@ -483844,7 +484094,7 @@ async function handleDevMode(adapter, gatewayConfig, daemon) {
     return;
   }
   const hiveUiPath = path36.join(process.cwd(), "packages/hive-ui");
-  const hasVite = existsSync33(path36.join(hiveUiPath, "package.json"));
+  const hasVite = existsSync35(path36.join(hiveUiPath, "package.json"));
   if (hasVite) {
     console.log(`\uD83C\uDFA8 Iniciando Vite (UI)...
 `);
@@ -484093,7 +484343,7 @@ async function handleProductionMode(adapter, gatewayConfig, daemon) {
     } catch {
       const hiveDir = getHiveDir();
       const dbPath = path36.join(hiveDir, "data", "hive.db");
-      needsSetup = !existsSync33(dbPath);
+      needsSetup = !existsSync35(dbPath);
     }
     const url2 = needsSetup ? `http://localhost:${uiPort}/setup` : `http://localhost:${uiPort}`;
     if (needsSetup) {
@@ -484128,7 +484378,7 @@ async function stop() {
     return;
   }
   const pidFile = await getPidFile();
-  const pid = parseInt(readFileSync17(pidFile, "utf-8").trim(), 10);
+  const pid = parseInt(readFileSync18(pidFile, "utf-8").trim(), 10);
   try {
     process.kill(pid, "SIGTERM");
     unlinkSync7(pidFile);
@@ -484174,7 +484424,7 @@ async function reload() {
     return;
   }
   const pidFile = await getPidFile();
-  const pid = parseInt(readFileSync17(pidFile, "utf-8").trim(), 10);
+  const pid = parseInt(readFileSync18(pidFile, "utf-8").trim(), 10);
   try {
     process.kill(pid, "SIGHUP");
     console.log("\u2705 Configuraci\xF3n recargada");
@@ -484933,11 +485183,11 @@ async function updateSkills() {
     } else {
       console.log(`   \u2705 Todas las skills est\xE1n actualizadas`);
     }
-    const { existsSync: existsSync37 } = await import("fs");
+    const { existsSync: existsSync39 } = await import("fs");
     const { getHiveDir: getHiveDir3 } = await Promise.resolve().then(() => (init_loader(), exports_loader));
     const path40 = await import("path");
     const pidFile = path40.join(getHiveDir3(), "gateway.pid");
-    if (existsSync37(pidFile)) {
+    if (existsSync39(pidFile)) {
       console.log(`
    \uD83D\uDCA1 El gateway est\xE1 corriendo. Ejecuta 'hive reload' para aplicar cambios.`);
     }
@@ -486211,8 +486461,8 @@ var MAIN_PACKAGE = "@johpaz/hive-agents";
 async function update() {
   console.log(`\uD83D\uDD04 Actualizando Hive...
 `);
-  const { existsSync: existsSync43 } = await import("fs");
-  const isGitRepo = existsSync43(".git") && existsSync43("package.json");
+  const { existsSync: existsSync45 } = await import("fs");
+  const isGitRepo = existsSync45(".git") && existsSync45("package.json");
   if (isGitRepo) {
     await updateFromGitRepo();
   } else {
@@ -486314,11 +486564,11 @@ Descargando ${MAIN_PACKAGE}@latest (via ${packageManager})...`);
   }
 }
 async function applyDatabaseUpdates() {
-  const { existsSync: existsSync43 } = await import("fs");
+  const { existsSync: existsSync45 } = await import("fs");
   const { getHiveDir: getHiveDir3 } = await Promise.resolve().then(() => (init_loader(), exports_loader));
   const path45 = await import("path");
   const dbPath = path45.join(getHiveDir3(), "data", "hive.db");
-  if (!existsSync43(dbPath)) {
+  if (!existsSync45(dbPath)) {
     console.log(`   \u2139\uFE0F  No se encontr\xF3 base de datos existente. Se crear\xE1 en el pr\xF3ximo 'hive start'.`);
     return;
   }
@@ -486356,7 +486606,7 @@ async function applyDatabaseUpdates() {
     }
     const hiveDir = getHiveDir3();
     const pidFile = path45.join(hiveDir, "gateway.pid");
-    if (existsSync43(pidFile)) {
+    if (existsSync45(pidFile)) {
       console.log(`
    \uD83D\uDCA1 El gateway est\xE1 corriendo. Ejecuta 'hive reload' para aplicar cambios.`);
     }