@agentprojectcontext/apx 1.80.2 → 1.89.1

package/src/interfaces/desktop/main.js

@@ -9,7 +9,7 @@
 // Or via:     apx desktop start
 
 "use strict";
-const { app, BrowserWindow, Tray, globalShortcut, ipcMain, nativeImage, screen, Menu } = require("electron");
+const { app, BrowserWindow, Tray, globalShortcut, ipcMain, nativeImage, screen, Menu, shell } = require("electron");
 const path = require("path");
 const os = require("os");
 const fs = require("fs");
@@ -124,6 +124,54 @@ function getAgentName() {
   return "Superagente";
 }
 
+// ── Mascot (blob pet) config ────────────────────────────────────────────────
+// Which blob the pet wears: the shared super-agent avatar, then the legacy
+// desktop-only override, then the default. The web picker writes the shared key.
+function getMascotBlob() {
+  const cfg = readApxConfig();
+  const key = cfg?.super_agent?.icon || cfg?.desktop?.blob;
+  return (typeof key === "string" && key.trim()) ? key.trim() : "noche";
+}
+
+// The pet is on by default — the user asked for it. Disable with
+//   "desktop": { "mascot": false }
+function getMascotEnabled() {
+  const cfg = readApxConfig();
+  return cfg?.desktop?.mascot !== false;
+}
+
+// Message sounds are on by default. The checkbox in the native context menus
+// persists this setting independently from the mascot visibility toggle.
+function getMascotSoundEnabled() {
+  const cfg = readApxConfig();
+  return cfg?.desktop?.mascot_sound !== false;
+}
+
+// Saved pet position ({x,y} in screen coords), or null for the default corner.
+function getMascotPos() {
+  const cfg = readApxConfig();
+  const p = cfg?.desktop?.mascot_pos;
+  if (p && typeof p.x === "number" && typeof p.y === "number") return p;
+  return null;
+}
+
+// Persist a partial patch into config.json's `desktop` block, preserving every
+// other field. Best-effort — a write failure just means the pet forgets where
+// it was left, which is harmless.
+function patchDesktopConfig(patch) {
+  try {
+    const cfg = readApxConfig();
+    cfg.desktop = { ...(cfg.desktop || {}), ...patch };
+    fs.writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2) + "\n", "utf8");
+  } catch (e) {
+    console.warn("desktop: could not persist mascot config —", e.message);
+  }
+}
+
+function toggleMascotSound() {
+  patchDesktopConfig({ mascot_sound: !getMascotSoundEnabled() });
+}
+
 function getWindowOrigin(_height) {
   const display = screen.getPrimaryDisplay();
   const { workArea } = display;
@@ -139,6 +187,7 @@ function getWindowOrigin(_height) {
 // ---------------------------------------------------------------------------
 
 let mainWindow = null;
+let mascotWindow = null; // the draggable blob pet (separate always-on-top window)
 let tray = null;
 let wsConn = null; // WebSocket to daemon
 let isRecording = false;
@@ -169,9 +218,12 @@ app.whenReady().then(() => {
   catch (e) { console.error("desktop: createTray failed:", e.message); }
   try { createWindow();      console.log("desktop: window created"); }
   catch (e) { console.error("desktop: createWindow failed:", e.message); }
+  try { if (getMascotEnabled()) { createMascotWindow(); console.log("desktop: mascot created"); } }
+  catch (e) { console.error("desktop: createMascotWindow failed:", e.message); }
   try { registerShortcut(); }
   catch (e) { console.error("desktop: registerShortcut failed:", e.message); }
   connectDaemon();
+  connectEventsFeed();
 });
 
 process.on("uncaughtException", (e) => {
@@ -213,13 +265,28 @@ function createTray() {
   tray = new Tray(icon);
 
   // No extra text label on macOS — the icon is the brand mark.
-  tray.setToolTip("APX Desktop — click to toggle, right-click for menu");
+  tray.setToolTip("APX Desktop — click para abrir, click derecho para el menú");
 
-  const contextMenu = Menu.buildFromTemplate([
-    { label: "Show / Hide",    click: toggleWindow },
-    { label: "Start Recording", click: () => { showOverlay(); startRecording(); } },
+  // Built fresh on each right-click so the "Blob mascota" checkbox reflects the
+  // pet's live on/off state.
+  const buildMenu = () => Menu.buildFromTemplate([
+    { label: "Mostrar / ocultar",  click: toggleWindow },
+    { label: "Grabar",             click: () => { showOverlay(); startRecording(); } },
     { type: "separator" },
-    { label: "Quit APX Desktop", click: () => app.exit(0) },
+    {
+      label: "Blob mascota",
+      type: "checkbox",
+      checked: !!mascotWindow,
+      click: toggleMascot,
+    },
+    {
+      label: "Sonido de mensajes",
+      type: "checkbox",
+      checked: getMascotSoundEnabled(),
+      click: toggleMascotSound,
+    },
+    { type: "separator" },
+    { label: "Salir de APX Desktop", click: () => app.exit(0) },
   ]);
 
   // IMPORTANT on macOS: do NOT call tray.setContextMenu(contextMenu).
@@ -229,7 +296,7 @@ function createTray() {
   //   left-click  → toggle the floating window
   //   right-click → pop up the context menu
   tray.on("click",       () => toggleWindow());
-  tray.on("right-click", () => tray.popUpContextMenu(contextMenu));
+  tray.on("right-click", () => tray.popUpContextMenu(buildMenu()));
 }
 
 function updateTrayRecording(rec) {
@@ -337,6 +404,92 @@ function reloadDesktopWindow() {
   }
 }
 
+// ---------------------------------------------------------------------------
+// Mascot (blob pet) window
+// ---------------------------------------------------------------------------
+//
+// A second, tiny, transparent, always-on-top window that hosts just the blob
+// avatar. It is draggable anywhere on screen, click-through over its
+// transparent pixels (only the blob + bubble opt back into the mouse), and
+// floats notification bubbles relayed from the daemon. Clicking it toggles the
+// voice HUD. Kept fully separate from the voice window so neither disturbs the
+// other.
+
+const MASCOT_W = 240;
+const MASCOT_H = 210;
+const MASCOT_MARGIN = 16;
+
+function getMascotOrigin() {
+  const saved = getMascotPos();
+  const { workArea } = screen.getPrimaryDisplay();
+  if (saved) {
+    // Clamp a stale saved position back onto the visible work area.
+    const x = Math.min(Math.max(saved.x, workArea.x), workArea.x + workArea.width - MASCOT_W);
+    const y = Math.min(Math.max(saved.y, workArea.y), workArea.y + workArea.height - MASCOT_H);
+    return { x: Math.round(x), y: Math.round(y) };
+  }
+  // Default: bottom-right corner, above the dock/taskbar.
+  return {
+    x: workArea.x + workArea.width - MASCOT_W - MASCOT_MARGIN,
+    y: workArea.y + workArea.height - MASCOT_H - MASCOT_MARGIN,
+  };
+}
+
+function createMascotWindow() {
+  if (mascotWindow) return;
+  const origin = getMascotOrigin();
+  mascotWindow = new BrowserWindow({
+    width: MASCOT_W,
+    height: MASCOT_H,
+    x: origin.x,
+    y: origin.y,
+    frame: false,
+    transparent: true,
+    alwaysOnTop: true,
+    skipTaskbar: true,
+    resizable: false,
+    hasShadow: false,
+    focusable: false,     // a pet never steals keyboard focus
+    fullscreenable: false,
+    show: false,
+    webPreferences: {
+      preload: path.join(__dirname, "mascot-preload.js"),
+      contextIsolation: true,
+      nodeIntegration: false,
+      autoplayPolicy: "no-user-gesture-required",
+    },
+  });
+
+  // Follow the user across spaces / full-screen apps, and float above them.
+  try {
+    mascotWindow.setVisibleOnAllWorkspaces(true, { visibleOnFullScreen: true });
+    mascotWindow.setAlwaysOnTop(true, "screen-saver");
+  } catch {}
+
+  // Start click-through; the renderer re-enables the mouse only over the blob.
+  mascotWindow.setIgnoreMouseEvents(true, { forward: true });
+
+  mascotWindow.loadFile(path.join(__dirname, "mascot.html"));
+  mascotWindow.once("ready-to-show", () => mascotWindow.showInactive());
+  mascotWindow.on("closed", () => { mascotWindow = null; });
+}
+
+function destroyMascotWindow() {
+  if (!mascotWindow) return;
+  try { mascotWindow.close(); } catch {}
+  mascotWindow = null;
+}
+
+function toggleMascot() {
+  if (mascotWindow) {
+    destroyMascotWindow();
+    patchDesktopConfig({ mascot: false });
+  } else {
+    patchDesktopConfig({ mascot: true });
+    createMascotWindow();
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Global shortcut: Cmd/Ctrl+Shift+Space toggles recording
 // ---------------------------------------------------------------------------
@@ -423,9 +576,8 @@ ipcMain.handle("cancel", async () => {
   stopRecording();
 });
 
-// Renderer requests close/hide (legacy "close-overlay" still accepted)
+// Renderer requests close/hide
 ipcMain.handle("close-desktop", async () => { hideOverlay(); });
-ipcMain.handle("close-overlay", async () => { hideOverlay(); });
 
 // Renderer queries the configured shortcut for display
 ipcMain.handle("get-shortcut", () => getShortcut());
@@ -434,6 +586,77 @@ ipcMain.handle("get-position", () => getPosition());
 ipcMain.handle("get-agent-name", () => getAgentName());
 ipcMain.handle("get-voice-timing", () => getVoiceTiming());
 
+// ── Mascot (blob pet) IPC ───────────────────────────────────────────────────
+ipcMain.handle("mascot-get-config", () => ({
+  blob: getMascotBlob(),
+  name: getAgentName(),
+  theme: getTheme(),
+  sound: getMascotSoundEnabled(),
+}));
+
+ipcMain.handle("mascot-get-bounds", () => {
+  if (!mascotWindow) return { x: 0, y: 0, width: MASCOT_W, height: MASCOT_H };
+  return mascotWindow.getBounds();
+});
+
+ipcMain.on("mascot-set-pos", (_e, { x, y }) => {
+  if (!mascotWindow) return;
+  if (typeof x !== "number" || typeof y !== "number") return;
+  mascotWindow.setPosition(Math.round(x), Math.round(y));
+});
+
+ipcMain.on("mascot-save-pos", () => {
+  if (!mascotWindow) return;
+  const [x, y] = mascotWindow.getPosition();
+  patchDesktopConfig({ mascot_pos: { x, y } });
+});
+
+// A clean click on the blob toggles the voice HUD.
+ipcMain.handle("mascot-poke", () => { toggleWindow(); });
+
+// Right-click on the blob → a native context menu at the cursor. Mirrors the
+// tray menu, plus a shortcut to open the full chat in the browser.
+ipcMain.handle("mascot-menu", () => {
+  const menu = Menu.buildFromTemplate([
+    { label: "Abrir chat en el navegador", click: openWebChat },
+    { type: "separator" },
+    { label: "Mostrar / ocultar voz", click: toggleWindow },
+    { label: "Grabar", click: () => { showOverlay(); startRecording(); } },
+    { label: "Probar notificación", click: testMascotNotify },
+    { type: "separator" },
+    { label: "Blob mascota", type: "checkbox", checked: !!mascotWindow, click: toggleMascot },
+    { label: "Sonido de mensajes", type: "checkbox", checked: getMascotSoundEnabled(), click: toggleMascotSound },
+    { type: "separator" },
+    { label: "Salir", click: () => app.exit(0) },
+  ]);
+  menu.popup({ window: mascotWindow || undefined });
+});
+
+// Fire a sample bubble on the pet — lets you preview notifications without
+// sending a real message through a channel.
+function testMascotNotify() {
+  if (!mascotWindow) return;
+  mascotWindow.webContents.send("mascot-notify", {
+    text: "Nuevo mensaje en Telegram",
+    sound: getMascotSoundEnabled(),
+  });
+}
+
+// Open the APX web chat in the user's default browser. The daemon serves the
+// web UI at its own host:port.
+function openWebChat() {
+  const url = `http://${DAEMON_HOST}:${DAEMON_PORT}/`;
+  shell.openExternal(url).catch((e) => console.warn("desktop: openWebChat failed —", e.message));
+}
+
+// Click-through toggling — ignore the mouse over transparent pixels, capture it
+// over the blob/bubble. `forward:true` keeps move events flowing so the
+// renderer can tell when the pointer re-enters an interactive region.
+ipcMain.on("mascot-set-ignore", (_e, { ignore }) => {
+  if (!mascotWindow) return;
+  mascotWindow.setIgnoreMouseEvents(!!ignore, { forward: true });
+});
+
 // Renderer asks main to grow/shrink the window to fit its content.
 // Clamped to [WIN_H_MIN, getMaxWindowHeight()]; same anchor (top edge stays put).
 ipcMain.on("resize-window", (_e, { height }) => {
@@ -447,29 +670,116 @@ ipcMain.on("resize-window", (_e, { height }) => {
 // Renderer asks for TTS playback of the agent reply. We synthesize via the
 // daemon and pipe the audio path back as a daemon-event the renderer already
 // knows how to consume (tts-ready { url, duration } / tts-failed).
+// Speech is generated a sentence at a time so the first one can start playing
+// while the rest is still being made. The engine runs at roughly 0.85x real
+// time, which means every sentence finishes generating before the one ahead of
+// it finishes playing — so the reply comes out continuous, but Roby starts
+// talking after the first sentence instead of after the whole answer. Measured
+// on a two-sentence reply: first audio at 2.0s instead of 4.8s, and the gap
+// grows with the length of the answer.
+//
+// The limit mirrors the engine's own chunking. Past ~80 characters the model
+// stops finding its end token and the audio degrades, so there is nothing to
+// gain by sending it more in one go.
+function splitForSpeech(text, { min = 12, limit = 80 } = {}) {
+  const out = [];
+  let cur = "";
+  const flush = () => { if (cur) { out.push(cur); cur = ""; } };
+  const add = (piece) => {
+    if (!piece) return;
+    if (cur && cur.length + 1 + piece.length > limit) flush();
+    cur = cur ? `${cur} ${piece}` : piece;
+    // Cut as soon as there is enough to say. Packing sentences up to the limit
+    // would undo the point of this: two sentences that fit in one chunk get
+    // generated together, and the listener waits for both before hearing
+    // either. `min` only exists so a two-word sentence doesn't become a
+    // generation of its own, and it is deliberately small: a short greeting
+    // degrades the whole chunk it is folded into. "¡Hola Manu!" alone is
+    // bounded to about a second of possible damage, but merged ahead of a full
+    // sentence it took the pair from 13 chars/s down to 8.
+    if (cur.length >= min) flush();
+  };
+  for (const sentence of String(text).trim().split(/(?<=[.!?…])\s+/)) {
+    if (sentence.length <= limit) { add(sentence); continue; }
+    // A sentence too long on its own: break it at clauses, then words.
+    for (const clause of sentence.split(/(?<=[,;:—–])\s+/)) {
+      if (clause.length <= limit) { add(clause); continue; }
+      for (const word of clause.split(" ")) add(word);
+    }
+  }
+  flush();
+  return out.length ? out : [String(text)];
+}
+
+// Speech generated ahead of the request for it, keyed by the exact chunk text.
+// The renderer kicks this the moment the first sentence has streamed in, so the
+// voice engine works during the model's remaining tokens instead of after them
+// — the single longest stretch of dead time in a voice turn. A key that never
+// gets claimed just means one small wasted synthesis, never wrong audio: only
+// an exact text match is ever served from here.
+const ttsAhead = new Map();   // chunk text -> Promise<{ok, audio_path, ...}>
+
+ipcMain.handle("prewarm-tts", async (_e, { text }) => {
+  const first = splitForSpeech(text || "")[0];
+  // splitForSpeech packs sentences shorter than its `min` together with the
+  // next one, so a short opener would be pre-made as the wrong chunk. The
+  // renderer already filters those out; this is the backstop.
+  if (!first || first !== (text || "").trim() || ttsAhead.has(first)) return;
+  if (ttsAhead.size > 4) ttsAhead.clear();   // a turn never needs more than one
+  const t0 = Date.now();
+  ttsAhead.set(first, daemonTtsSay(first)
+    .then((r) => {
+      console.log(`desktop: speech-ahead ready in ${Date.now() - t0}ms — "${first.slice(0, 48)}"`);
+      return r;
+    })
+    .catch(() => ({ ok: false })));
+});
+
 ipcMain.handle("request-tts", async (_e, { text, seg }) => {
+  const send = (msg) => mainWindow?.webContents.send("daemon-event", msg);
   if (!text || !text.trim()) {
-    mainWindow?.webContents.send("daemon-event", { type: "tts-failed", seg });
+    send({ type: "tts-failed", seg });
     return;
   }
+  const chunks = splitForSpeech(text);
+  let delivered = 0;
   try {
-    const result = await daemonTtsSay(text);
-    if (result?.ok && result.audio_path) {
-      // Expose the local file via file:// — preload's contextIsolation lets
-      // the renderer's <audio> tag fetch it directly. `seg` ties this audio to
-      // the bubble that asked for it.
-      const url = "file://" + result.audio_path;
-      mainWindow?.webContents.send("daemon-event", {
-        type: "tts-ready",
-        seg,
-        url,
-        duration: result.duration_s || 0,
-      });
-    } else {
-      mainWindow?.webContents.send("daemon-event", { type: "tts-failed", seg, error: result?.error || "no audio" });
+    for (const chunk of chunks) {
+      const ahead = ttsAhead.get(chunk);
+      if (ahead) ttsAhead.delete(chunk);
+      if (delivered === 0) {
+        console.log(`desktop: first chunk ${ahead ? "claimed from speech-ahead" : "synthesized on demand"}`);
+      }
+      const result = ahead ? await ahead : await daemonTtsSay(chunk);
+      if (result?.ok && result.audio_path) {
+        // Expose the local file via file:// — preload's contextIsolation lets
+        // the renderer's <audio> tag fetch it directly. `seg` ties this audio
+        // to the bubble that asked for it.
+        send({
+          type: "tts-part",
+          seg,
+          url: "file://" + result.audio_path,
+          duration: result.duration_s || 0,
+        });
+        delivered++;
+      } else if (!delivered) {
+        // Nothing has played yet and the engine is refusing: stop asking. A
+        // whole reply of failures would otherwise cost one full timeout each.
+        send({ type: "tts-failed", seg, error: result?.error || "no audio" });
+        return;
+      }
+      // A later chunk failing is survivable — the bubble keeps what it has.
     }
+    // Anything still sitting here was pre-made for a sentence this reply never
+    // asked for (the model revised it, or a tag/emoji changed the chunk).
+    ttsAhead.clear();
+    // Tells the renderer no more audio is coming, so a player waiting on the
+    // next sentence knows it has reached the end instead of stalling.
+    send({ type: "tts-end", seg, parts: delivered });
+    if (!delivered) send({ type: "tts-failed", seg, error: "no audio" });
   } catch (e) {
-    mainWindow?.webContents.send("daemon-event", { type: "tts-failed", seg, error: e.message });
+    if (delivered) send({ type: "tts-end", seg, parts: delivered });
+    else send({ type: "tts-failed", seg, error: e.message });
   }
 });
 
@@ -526,6 +836,30 @@ ipcMain.handle("warmup-stt", async () => {
   });
 });
 
+// Same idea as warmup-stt, for the other half of the round trip. Fired when
+// the mic opens: the user then spends a few seconds speaking, and the voice
+// engine spends them getting its weights back into RAM instead of making the
+// reply wait afterwards.
+ipcMain.handle("warmup-tts", async () => {
+  return new Promise((resolve) => {
+    const token = readToken();
+    const req = http.request({
+      hostname: DAEMON_HOST,
+      port: DAEMON_PORT,
+      path: "/api/tts/warmup",
+      method: "GET",
+      headers: { ...(token ? { "Authorization": `Bearer ${token}` } : {}) },
+    }, (res) => {
+      let data = "";
+      res.on("data", (c) => data += c);
+      res.on("end", () => { try { resolve(JSON.parse(data)); } catch { resolve({ ok: false }); } });
+    });
+    req.on("error", () => resolve({ ok: false }));
+    req.setTimeout(120000, () => { req.destroy(); resolve({ ok: false }); });
+    req.end();
+  });
+});
+
 // Renderer requests recording toggle (ESC cancels, shortcut toggles)
 ipcMain.handle("toggle-recording", async () => {
   if (isRecording) stopRecording(); else startRecording();
@@ -644,6 +978,104 @@ function connectDaemon() {
   connect();
 }
 
+// ---------------------------------------------------------------------------
+// Cross-channel event feed → mascot notifications
+// ---------------------------------------------------------------------------
+//
+// A SECOND socket, to /api/events/ws (distinct from the desktop conversation
+// socket above). It carries a signal-only "the channel X moved" feed. The
+// daemon already decided which bursts are news (`notifications: string[]`):
+// an agent's launched final on Telegram / group / A2A, plus delivery
+// headlines. The owner's own send is NOT news — it used to bubble here
+// because the filter watched `direction: "in"`. Only meaningful while the
+// pet is on.
+
+function connectEventsFeed() {
+  let WS;
+  try { WS = require("ws"); } catch { return; } // already warned in connectDaemon
+
+  const url = `ws://${DAEMON_HOST}:${DAEMON_PORT}/api/events/ws`;
+  let conn = null;
+  let reconnectDelay = 1000;
+
+  function scheduleReconnect() {
+    const delay = reconnectDelay;
+    reconnectDelay = Math.min(reconnectDelay * 2, 30000);
+    setTimeout(connect, delay);
+  }
+
+  function pushBubble(text) {
+    if (!text || !mascotWindow) return;
+    mascotWindow.webContents.send("mascot-notify", { text, sound: getMascotSoundEnabled() });
+  }
+
+  function handleFrame(msg) {
+    const avatar = msg?.settings?.super_agent?.icon;
+    if ((msg?.type === "hello" || msg?.type === "settings") && typeof avatar === "string") {
+      mascotWindow?.webContents.send("mascot-avatar", avatar);
+    }
+    if (!msg || msg.type !== "messages") return;
+    if (!mascotWindow) return; // pet off → nothing to notify
+
+    // The daemon computes the copy. An empty array means "this burst is not
+    // news" (the owner sending) and must not fall through to a local guess.
+    if (Array.isArray(msg.notifications)) {
+      for (const text of msg.notifications) pushBubble(text);
+      return;
+    }
+
+    // Older daemon without the field: still skip the owner's send, only
+    // bubble an agent's launched final on Telegram / group / A2A plus the
+    // delivery headlines the previous local filter already knew about.
+    const events = Array.isArray(msg.events) ? msg.events : [];
+    for (const ev of events) {
+      if (ev?.via === "mobility_delivery" && ev.notify) pushBubble(ev.notify);
+    }
+    const byAgent = new Map();
+    for (const ev of events) {
+      if (!ev || ev.via !== "routine_delivery" || ev.channel !== "web") continue;
+      if (!ev.agent_slug || ev.agent_slug === "super_agent") continue;
+      byAgent.set(ev.agent_slug, ev.notify || byAgent.get(ev.agent_slug) || "");
+    }
+    for (const [agent, notify] of byAgent) {
+      pushBubble(notify ? `${agent}: ${notify}` : `${agent} te dejó un mensaje`);
+    }
+    const finals = new Map();
+    for (const ev of events) {
+      if (!ev || ev.direction !== "out") continue;
+      if (ev.type && ev.type !== "agent") continue;
+      if (ev.channel !== "telegram" && ev.channel !== "group" && ev.channel !== "a2a") continue;
+      if (ev.streamed === true) continue;
+      if (ev.via === "routine_delivery" || ev.via === "mobility_delivery") continue;
+      const agent = (ev.author && ev.author !== "user" && ev.author !== "owner")
+        ? ev.author
+        : (ev.agent_slug || "agente");
+      const label = ev.channel === "telegram" ? "Telegram" : ev.channel === "group" ? "Grupo" : "A2A";
+      finals.set(`${ev.channel}|${agent}`, `${agent} respondió en ${label}`);
+    }
+    for (const text of finals.values()) pushBubble(text);
+  }
+
+  function connect() {
+    const token = readToken();
+    try {
+      conn = new WS(url, { headers: token ? { Authorization: `Bearer ${token}` } : {} });
+      conn.on("open", () => { reconnectDelay = 1000; console.log("desktop: events feed connected"); });
+      conn.on("message", (raw) => {
+        let msg; try { msg = JSON.parse(raw.toString()); } catch { return; }
+        handleFrame(msg);
+      });
+      conn.on("close", () => { conn = null; scheduleReconnect(); });
+      conn.on("error", (e) => { console.warn("desktop events-feed ws error:", e.message); });
+    } catch (e) {
+      console.warn("desktop: events feed connect failed —", e.message);
+      scheduleReconnect();
+    }
+  }
+
+  connect();
+}
+
 async function sendMessageToDaemon(text, previousMessages) {
   const token = readToken();
   return new Promise((resolve, reject) => {
@@ -681,11 +1113,18 @@ async function sendMessageToDaemon(text, previousMessages) {
 // engine), retry once with `provider: "mock"` so the renderer at least gets
 // a duration + scrubber instead of hanging. The user can plug a real TTS
 // engine in via the Voices web admin to get audible speech.
+// The daemon's chain already tries every configured engine, so there is nothing
+// left to retry here. It used to fall back to the `mock` engine, which returns
+// a silent WAV of about the right length: the bubble grew a working-looking
+// player, the progress bar ran to the end, and no sound ever came out. A turn
+// with no voice should say so, not mime one — so a mock result is reported as
+// a failure and the bubble simply stays text.
 function daemonTtsSay(text) {
   return _ttsRequest(text, /* explicitProvider */ null).then((r) => {
-    if (r.ok) return r;
-    console.warn(`desktop: tts chain failed (${r.error}) — retrying with mock`);
-    return _ttsRequest(text, /* explicitProvider */ "mock");
+    if (r.ok && r.provider === "mock") {
+      return { ok: false, error: "no TTS engine answered (silent placeholder)" };
+    }
+    return r;
   });
 }
 
@@ -721,7 +1160,12 @@ function _ttsRequest(text, explicitProvider) {
       });
     });
     req.on("error", (e) => resolve({ ok: false, error: e.message }));
-    req.setTimeout(30_000, () => { req.destroy(); resolve({ ok: false, error: "tts timeout" }); });
+    // Generous on purpose. A sentence normally comes back in a second or two,
+    // but the first one after the engine starts pays for loading a
+    // multi-gigabyte model, and 30s was cutting that off — the reply lost its
+    // voice for the one reason the user can do nothing about. Waiting is worse
+    // than instant; silence is worse than waiting.
+    req.setTimeout(120_000, () => { req.destroy(); resolve({ ok: false, error: "tts timeout" }); });
     req.write(body);
     req.end();
   });

package/src/interfaces/desktop/mascot-blobs.js

@@ -0,0 +1,41 @@
+// AUTO-GENERATED from src/interfaces/web/src/components/agents/blobPresets.ts
+// Vanilla mirror for the Electron mascot window. Keep in sync by re-running the
+// generator in the desktop mascot build (see chat history / commit).
+const BLOB_VIEWBOX = 256;
+const BLOB_PRESETS = {
+  menta: { key: "menta", label: "Menta", src: "./assets/blobs/menta.png", eyeColor: "#15181C", eyes: [{ x: 121.9, y: 93.1, w: 16.0, h: 33.8, rx: 6.4 }, { x: 151.9, y: 93.1, w: 16.0, h: 33.8, rx: 6.4 }] },
+  parche: { key: "parche", label: "Parche", src: "./assets/blobs/parche.png", eyeColor: "#15181C", eyes: [{ x: 133.6, y: 88.6, w: 17.3, h: 33.8, rx: 6.9 }, { x: 166.1, y: 88.6, w: 17.3, h: 33.8, rx: 6.9 }] },
+  trino: { key: "trino", label: "Trino", src: "./assets/blobs/trino.png", eyeColor: "#15181C", eyes: [{ x: 105.5, y: 130.1, w: 18.0, h: 29.7, rx: 7.2 }, { x: 141.5, y: 130.1, w: 18.0, h: 29.7, rx: 7.2 }] },
+  cubi: { key: "cubi", label: "Cubi", src: "./assets/blobs/cubi.png", eyeColor: "#15181C", eyes: [{ x: 103.2, y: 93.1, w: 17.2, h: 33.8, rx: 6.9 }, { x: 135.6, y: 93.1, w: 17.2, h: 33.8, rx: 6.9 }] },
+  nimbo: { key: "nimbo", label: "Nimbo", src: "./assets/blobs/nimbo.png", eyeColor: "#15181C", eyes: [{ x: 103.3, y: 93.1, w: 17.1, h: 33.8, rx: 6.9 }, { x: 135.6, y: 93.1, w: 17.1, h: 33.8, rx: 6.9 }] },
+  papa: { key: "papa", label: "Papa", src: "./assets/blobs/papa.png", eyeColor: "#15181C", eyes: [{ x: 125.5, y: 90.9, w: 18.5, h: 30.5, rx: 7.4 }, { x: 161.6, y: 90.9, w: 18.5, h: 30.5, rx: 7.4 }] },
+  noche: { key: "noche", label: "Noche", src: "./assets/blobs/noche.png", eyeColor: "#3AE7B0", eyes: [{ x: 123.8, y: 133.6, w: 15.9, h: 33.8, rx: 6.4 }, { x: 157.6, y: 133.6, w: 15.9, h: 33.8, rx: 6.4 }] },
+  kiwi: { key: "kiwi", label: "Kiwi", src: "./assets/blobs/kiwi.png", eyeColor: "#15181C", eyes: [{ x: 123.0, y: 84.1, w: 13.1, h: 29.3, rx: 5.2 }, { x: 147.7, y: 84.1, w: 13.1, h: 29.3, rx: 5.2 }] },
+  gajo: { key: "gajo", label: "Gajo", src: "./assets/blobs/gajo.png", eyeColor: "#15181C", eyes: [{ x: 107.9, y: 95.3, w: 16.6, h: 29.3, rx: 6.7 }, { x: 139.3, y: 95.3, w: 16.6, h: 29.3, rx: 6.7 }] },
+  campana: { key: "campana", label: "Campana", src: "./assets/blobs/campana.png", eyeColor: "#15181C", eyes: [{ x: 108.6, y: 86.3, w: 15.8, h: 29.3, rx: 6.3 }, { x: 135.5, y: 86.3, w: 15.8, h: 29.3, rx: 6.3 }] },
+  cobalto: { key: "cobalto", label: "Cobalto", src: "./assets/blobs/cobalto.png", eyeColor: "#15181C", eyes: [{ x: 125.5, y: 95.3, w: 16.8, h: 29.3, rx: 6.7 }, { x: 157.2, y: 95.3, w: 16.8, h: 29.3, rx: 6.7 }] },
+  rubi: { key: "rubi", label: "Rubí", src: "./assets/blobs/rubi.png", eyeColor: "#15181C", eyes: [{ x: 123.0, y: 84.1, w: 13.1, h: 29.3, rx: 5.2 }, { x: 147.7, y: 84.1, w: 13.1, h: 29.3, rx: 5.2 }] },
+  trebol: { key: "trebol", label: "Trébol", src: "./assets/blobs/trebol.png", eyeColor: "#15181C", eyes: [{ x: 123.6, y: 120.1, w: 17.2, h: 29.3, rx: 6.9 }, { x: 155.1, y: 120.1, w: 17.2, h: 29.3, rx: 6.9 }] },
+  saturno: { key: "saturno", label: "Saturno", src: "./assets/blobs/saturno.png", eyeColor: "#15181C", eyes: [] },
+  onyx: { key: "onyx", label: "Onyx", src: "./assets/blobs/onyx.png", eyeColor: "#3AE7B0", eyes: [{ x: 119.7, y: 124.6, w: 16.6, h: 29.3, rx: 6.6 }, { x: 152.9, y: 124.6, w: 16.6, h: 29.3, rx: 6.6 }] },
+  perla: { key: "perla", label: "Perla", src: "./assets/blobs/perla.png", eyeColor: "#15181C", eyes: [{ x: 121.4, y: 108.4, w: 13.5, h: 21.4, rx: 5.4 }, { x: 148.5, y: 108.4, w: 13.5, h: 21.4, rx: 5.4 }] },
+  faro: { key: "faro", label: "Faro", src: "./assets/blobs/faro.png", eyeColor: "#15181C", eyes: [{ x: 94.4, y: 100.0, w: 14.2, h: 20.3, rx: 5.7 }, { x: 122.7, y: 100.0, w: 14.2, h: 20.3, rx: 5.7 }] },
+  brasa: { key: "brasa", label: "Brasa", src: "./assets/blobs/brasa.png", eyeColor: "#15181C", eyes: [{ x: 94.8, y: 95.2, w: 16.9, h: 18.6, rx: 6.8 }, { x: 126.3, y: 95.2, w: 16.9, h: 18.6, rx: 6.8 }] },
+  aqua: { key: "aqua", label: "Aqua", src: "./assets/blobs/aqua.png", eyeColor: "#15181C", eyes: [{ x: 92.9, y: 105.8, w: 10.9, h: 20.3, rx: 4.4 }, { x: 114.7, y: 105.8, w: 10.9, h: 20.3, rx: 4.4 }] },
+  coral: { key: "coral", label: "Coral", src: "./assets/blobs/coral.png", eyeColor: "#15181C", eyes: [{ x: 99.4, y: 147.0, w: 14.5, h: 19.1, rx: 5.8 }, { x: 129.3, y: 147.0, w: 14.5, h: 19.1, rx: 5.8 }] },
+  zafiro: { key: "zafiro", label: "Zafiro", src: "./assets/blobs/zafiro.png", eyeColor: "#15181C", eyes: [{ x: 105.7, y: 116.5, w: 14.3, h: 21.4, rx: 5.7 }, { x: 132.4, y: 116.5, w: 14.3, h: 21.4, rx: 5.7 }] },
+  pino: { key: "pino", label: "Pino", src: "./assets/blobs/pino.png", eyeColor: "#15181C", eyes: [{ x: 125.0, y: 123.2, w: 13.4, h: 20.3, rx: 5.4 }, { x: 151.9, y: 123.2, w: 13.4, h: 20.3, rx: 5.4 }] },
+  eclipse: { key: "eclipse", label: "Eclipse", src: "./assets/blobs/eclipse.png", eyeColor: "#060709", eyes: [{ x: 102.8, y: 111.9, w: 15.5, h: 20.3, rx: 6.2 }, { x: 131.5, y: 111.9, w: 15.5, h: 20.3, rx: 6.2 }] },
+  peon: { key: "peon", label: "Peón", src: "./assets/blobs/peon.png", eyeColor: "#15181C", eyes: [{ x: 109.1, y: 85.6, w: 10.2, h: 18.0, rx: 4.1 }, { x: 132.9, y: 85.6, w: 10.2, h: 18.0, rx: 4.1 }] },
+  ovni: { key: "ovni", label: "Ovni", src: "./assets/blobs/ovni.png", eyeColor: "#15181C", eyes: [{ x: 106.6, y: 105.0, w: 15.8, h: 16.0, rx: 6.3 }, { x: 138.1, y: 105.0, w: 15.8, h: 16.0, rx: 6.3 }] },
+  amatista: { key: "amatista", label: "Amatista", src: "./assets/blobs/amatista.png", eyeColor: "#15181C", eyes: [{ x: 85.8, y: 103.4, w: 16.9, h: 18.3, rx: 6.8 }, { x: 117.3, y: 103.4, w: 16.9, h: 18.3, rx: 6.8 }] },
+  volcan: { key: "volcan", label: "Volcán", src: "./assets/blobs/volcan.png", eyeColor: "#15181C", eyes: [{ x: 100.6, y: 97.4, w: 13.4, h: 19.1, rx: 5.4 }, { x: 127.5, y: 97.4, w: 13.4, h: 19.1, rx: 5.4 }] },
+  quad: { key: "quad", label: "Quad", src: "./assets/blobs/quad.png", eyeColor: "#15181C", eyes: [{ x: 80.9, y: 68.2, w: 17.6, h: 21.8, rx: 7.0 }, { x: 148.5, y: 68.2, w: 17.6, h: 21.8, rx: 7.0 }] },
+  cometa: { key: "cometa", label: "Cometa", src: "./assets/blobs/cometa.png", eyeColor: "#15181C", eyes: [{ x: 107.5, y: 94.8, w: 15.7, h: 21.4, rx: 6.3 }, { x: 136.9, y: 94.8, w: 15.7, h: 21.4, rx: 6.3 }] },
+  lila: { key: "lila", label: "Lila", src: "./assets/blobs/lila.png", eyeColor: "#15181C", eyes: [{ x: 104.8, y: 104.3, w: 14.1, h: 20.3, rx: 5.6 }, { x: 133.0, y: 104.3, w: 14.1, h: 20.3, rx: 5.6 }] },
+  orbita: { key: "orbita", label: "Órbita", src: "./assets/blobs/orbita.png", eyeColor: "#060709", eyes: [{ x: 104.3, y: 96.7, w: 15.8, h: 18.7, rx: 6.3 }, { x: 135.9, y: 96.7, w: 15.8, h: 18.7, rx: 6.3 }] },
+  caracol: { key: "caracol", label: "Caracol", src: "./assets/blobs/caracol.png", eyeColor: "#15181C", eyes: [{ x: 149.9, y: 109.4, w: 14.6, h: 17.1, rx: 5.9 }, { x: 181.4, y: 109.4, w: 14.6, h: 17.1, rx: 5.9 }] },
+  iris: { key: "iris", label: "Iris", src: "./assets/blobs/iris.png", eyeColor: "#15181C", eyes: [{ x: 97.7, y: 106.6, w: 13.7, h: 20.3, rx: 5.5 }, { x: 125.1, y: 106.6, w: 13.7, h: 20.3, rx: 5.5 }] },
+  laguna: { key: "laguna", label: "Laguna", src: "./assets/blobs/laguna.png", eyeColor: "#15181C", eyes: [{ x: 106.6, y: 83.8, w: 15.8, h: 18.5, rx: 6.3 }, { x: 138.1, y: 83.8, w: 15.8, h: 18.5, rx: 6.3 }] },
+  carbon: { key: "carbon", label: "Carbón", src: "./assets/blobs/carbon.png", eyeColor: "#060709", eyes: [{ x: 93.7, y: 99.3, w: 16.3, h: 21.4, rx: 6.5 }, { x: 124.2, y: 99.3, w: 16.3, h: 21.4, rx: 6.5 }] },
+};