clementine-agent 1.18.61 → 1.18.63

package/.env.example

@@ -36,6 +36,11 @@ WEBHOOK_SECRET=
 GROQ_API_KEY=
 ELEVENLABS_API_KEY=
 ELEVENLABS_VOICE_ID=
+VOICE_ENABLED=false
+VOICE_PROVIDER=gemini-live
+GEMINI_API_KEY=
+GEMINI_LIVE_MODEL=gemini-3.1-flash-live-preview
+GEMINI_LIVE_VOICE_NAME=Kore
 
 # ── Video (optional) ─────────────────────────────────────────────────
 GOOGLE_API_KEY=

package/dist/cli/dashboard.js

@@ -181,9 +181,28 @@ async function getGateway() {
             dispatcher.register('dashboard', async (text, context) => {
                 if (!dashboardSseBroadcast)
                     return;
+                // Forward agent identity so the chat panel can render the
+                // originating hired agent's name + initial — same UX guarantee
+                // Discord/Slack already give via per-agent bot identities.
+                // agentSlug arrives populated by either the explicit caller
+                // (cron-scheduler.dispatchContextForJob etc.) or by the
+                // dispatcher's session-key inference safety net.
+                let agentName = null;
+                if (context?.agentSlug && context.agentSlug !== 'clementine') {
+                    try {
+                        const profile = gatewayInstance?.getAgentManager().get(context.agentSlug);
+                        agentName = profile?.name ?? null;
+                    }
+                    catch { /* best-effort — fall back to slug */ }
+                }
                 dashboardSseBroadcast({
                     type: 'deep_result',
-                    data: { sessionKey: context?.sessionKey ?? null, text },
+                    data: {
+                        sessionKey: context?.sessionKey ?? null,
+                        agentSlug: context?.agentSlug ?? null,
+                        agentName,
+                        text,
+                    },
                 });
             });
             gatewayInstance.setDispatcher(dispatcher);
@@ -19551,6 +19570,51 @@ let currentPage = 'home';
 var currentAgentSlug = null;
 var prevAgentSlugs = null;
 
+// Browser-side cache of /api/agents — feeds chat-bubble identity rendering
+// so a hired agent's response shows their name/initial instead of
+// Clementine's. Refreshed on profile switch + on deep_result events
+// where the cache is missing the slug. Same UX guarantee Discord/Slack
+// give via per-agent bot identities.
+var __teamAgentsByslug = {};
+var __teamAgentsLoadedAt = 0;
+async function ensureTeamAgentCache(force) {
+  if (!force && __teamAgentsLoadedAt && (Date.now() - __teamAgentsLoadedAt < 60_000)) return;
+  try {
+    var r = await apiFetch('/api/agents');
+    if (!r.ok) return;
+    var agents = await r.json();
+    var next = {};
+    if (Array.isArray(agents)) {
+      for (var i = 0; i < agents.length; i++) {
+        var a = agents[i];
+        if (a && a.slug) next[a.slug] = { slug: a.slug, name: a.name || a.slug, avatar: a.avatar || null };
+      }
+    }
+    __teamAgentsByslug = next;
+    __teamAgentsLoadedAt = Date.now();
+  } catch (e) { /* non-fatal — fall back to Clementine */ }
+}
+
+/**
+ * Resolve the display identity for an assistant chat bubble.
+ *
+ *   getAssistantIdentity()                    → active chat profile (or Clementine)
+ *   getAssistantIdentity(slugFromSseEvent)    → that specific agent
+ *
+ * Returns { slug, name, initial }. Always safe — falls back to
+ * Clementine when nothing matches. Initial is uppercase first char,
+ * suitable for a .chat-avatar-sm bubble.
+ */
+function getAssistantIdentity(explicitSlug) {
+  var slug = explicitSlug || currentAgentSlug || '';
+  if (slug && slug !== 'clementine' && __teamAgentsByslug[slug]) {
+    var a = __teamAgentsByslug[slug];
+    return { slug: a.slug, name: a.name, initial: (a.name || 'A').charAt(0).toUpperCase() };
+  }
+  var clemName = (lastStatusData && lastStatusData.name) ? lastStatusData.name : 'Clementine';
+  return { slug: 'clementine', name: clemName, initial: clemName.charAt(0).toUpperCase() };
+}
+
 // ── Routing ────────────────────────────────────────────────────
 //
 // Five top-level destinations: home, build, team, brain, settings.
@@ -24359,18 +24423,23 @@ async function sendChat() {
   sendBtn.textContent = 'Thinking...';
 
 	  try {
+	    // Identity follows the active chat profile so a hired agent's
+	    // reply renders with their initial — same as Discord/Slack.
+	    await ensureTeamAgentCache();
+	    var asstIdentity = getAssistantIdentity();
 	    var asstRow = document.createElement('div');
 	    asstRow.className = 'chat-assistant-row';
 	    var chatAv = document.createElement('div');
 	    chatAv.className = 'chat-avatar-sm';
-	    chatAv.innerHTML = (lastStatusData.name || 'C').charAt(0).toUpperCase();
+	    chatAv.title = asstIdentity.name;
+	    chatAv.innerHTML = asstIdentity.initial;
 	    asstRow.appendChild(chatAv);
 	    var asstBubble = document.createElement('div');
 	    asstBubble.className = 'chat-bubble assistant';
 	    asstBubble.innerHTML = '<span style="color:var(--text-muted);font-style:italic">connecting...</span>';
 	    var asstMeta = document.createElement('div');
 	    asstMeta.className = 'chat-meta';
-	    asstMeta.textContent = new Date().toLocaleTimeString();
+	    asstMeta.textContent = new Date().toLocaleTimeString() + (asstIdentity.slug !== 'clementine' ? ' · ' + asstIdentity.name : '');
 	    asstRow.appendChild(asstBubble);
 	    container.appendChild(asstRow);
 	    typing.remove();
@@ -32436,6 +32505,21 @@ try {
         try {
           var container = document.getElementById('chat-messages');
           var text = (evt.data && evt.data.text) ? evt.data.text : '';
+          // Identity from the SSE payload \u2014 server-side
+          // dashboard sender resolves agentSlug + agentName from
+          // the dispatcher context (cron jobs, hired-agent
+          // workflows, heartbeats), so a Sasha-cron completion
+          // renders with Sasha's initial + name in the meta line
+          // instead of looking like Clementine sent it. Falls
+          // back to Clementine when the event is unowned.
+          var deepSlug = (evt.data && evt.data.agentSlug) ? evt.data.agentSlug : null;
+          var deepName = (evt.data && evt.data.agentName) ? evt.data.agentName : null;
+          // Lazy-refresh the cache if the SSE event names a slug we
+          // haven't seen yet (e.g. an agent hired since page load).
+          if (deepSlug && !__teamAgentsByslug[deepSlug]) { ensureTeamAgentCache(true); }
+          var deepIdentity = deepName
+            ? { slug: deepSlug, name: deepName, initial: deepName.charAt(0).toUpperCase() }
+            : getAssistantIdentity(deepSlug);
           if (container && text) {
             var emptyState = container.querySelector('.empty-state');
             if (emptyState) emptyState.remove();
@@ -32443,20 +32527,24 @@ try {
             row.className = 'chat-assistant-row';
             var av = document.createElement('div');
             av.className = 'chat-avatar-sm';
-            av.innerHTML = (lastStatusData && lastStatusData.name ? lastStatusData.name : 'C').charAt(0).toUpperCase();
+            av.title = deepIdentity.name;
+            av.innerHTML = deepIdentity.initial;
             row.appendChild(av);
             var bubble = document.createElement('div');
             bubble.className = 'chat-bubble assistant';
             bubble.innerHTML = renderMd(text);
             var meta = document.createElement('div');
             meta.className = 'chat-meta';
-            meta.textContent = new Date().toLocaleTimeString() + ' \u00b7 deep task';
+            meta.textContent = new Date().toLocaleTimeString()
+              + (deepIdentity.slug && deepIdentity.slug !== 'clementine' ? ' \u00b7 ' + deepIdentity.name : '')
+              + ' \u00b7 deep task';
             bubble.appendChild(meta);
             row.appendChild(bubble);
             container.appendChild(row);
             container.scrollTop = container.scrollHeight;
           } else {
-            toast('Deep task result ready \u2014 open chat to view.', 'info');
+            var who = (deepIdentity.slug && deepIdentity.slug !== 'clementine') ? deepIdentity.name : 'Deep task';
+            toast(who + ' result ready \u2014 open chat to view.', 'info');
           }
         } catch(e) { /* non-fatal */ }
       }

package/dist/config.d.ts

@@ -132,6 +132,11 @@ export declare const WEBHOOK_BIND: string;
 export declare const GROQ_API_KEY: string;
 export declare const ELEVENLABS_API_KEY: string;
 export declare const ELEVENLABS_VOICE_ID: string;
+export declare const VOICE_ENABLED: boolean;
+export declare const VOICE_PROVIDER: string;
+export declare const GEMINI_API_KEY: string;
+export declare const GEMINI_LIVE_MODEL: string;
+export declare const GEMINI_LIVE_VOICE_NAME: string;
 export declare const GOOGLE_API_KEY: string;
 export declare const MS_TENANT_ID: string;
 export declare const MS_CLIENT_ID: string;

package/dist/config.js

@@ -467,6 +467,11 @@ export const WEBHOOK_BIND = getEnv('WEBHOOK_BIND', '127.0.0.1');
 export const GROQ_API_KEY = getSecret('GROQ_API_KEY');
 export const ELEVENLABS_API_KEY = getSecret('ELEVENLABS_API_KEY');
 export const ELEVENLABS_VOICE_ID = getEnv('ELEVENLABS_VOICE_ID');
+export const VOICE_ENABLED = getEnv('VOICE_ENABLED', 'false').toLowerCase() === 'true';
+export const VOICE_PROVIDER = getEnv('VOICE_PROVIDER', 'gemini-live');
+export const GEMINI_API_KEY = getSecret('GEMINI_API_KEY') || getSecret('GOOGLE_API_KEY');
+export const GEMINI_LIVE_MODEL = getEnv('GEMINI_LIVE_MODEL', 'gemini-3.1-flash-live-preview');
+export const GEMINI_LIVE_VOICE_NAME = getEnv('GEMINI_LIVE_VOICE_NAME', 'Kore');
 // ── Video ────────────────────────────────────────────────────────────
 export const GOOGLE_API_KEY = getSecret('GOOGLE_API_KEY');
 // ── Outlook (Microsoft Graph) ───────────────────────────────────────

package/dist/desktop/main.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Clementine desktop shell.
+ *
+ * This process owns a native Electron window and supervises the existing
+ * dashboard server. The dashboard remains the single UI source of truth.
+ */
+export {};
+//# sourceMappingURL=main.d.ts.map

package/dist/desktop/main.js

@@ -0,0 +1,330 @@
+/**
+ * Clementine desktop shell.
+ *
+ * This process owns a native Electron window and supervises the existing
+ * dashboard server. The dashboard remains the single UI source of truth.
+ */
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import http from 'node:http';
+import os from 'node:os';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+const require = createRequire(import.meta.url);
+function loadElectron() {
+    try {
+        return require('electron');
+    }
+    catch {
+        console.error('Electron is not installed. Run `npm install`, then `npm run desktop`.');
+        process.exit(1);
+    }
+}
+const electron = loadElectron();
+const { app, BrowserWindow, Menu, Tray, nativeImage, shell, dialog, session } = electron;
+app.setName('Clementine');
+if (app.setAppUserModelId)
+    app.setAppUserModelId('com.clementine.assistant');
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const PACKAGE_ROOT = path.resolve(__dirname, '..', '..');
+const CLI_ENTRY = path.join(PACKAGE_ROOT, 'dist', 'cli', 'index.js');
+const ICONS_DIR = path.join(PACKAGE_ROOT, 'build', 'icons');
+const BASE_DIR = process.env.CLEMENTINE_HOME || path.join(os.homedir(), '.clementine');
+const DEFAULT_PORT = Number(process.env.CLEMENTINE_DESKTOP_PORT || process.env.DASHBOARD_PORT || 3030);
+const NODE_BINARY = process.env.CLEMENTINE_NODE_PATH || 'node';
+let mainWindow = null;
+let tray = null;
+let dashboardProcess = null;
+let dashboardUrl = `http://127.0.0.1:${DEFAULT_PORT}`;
+let observedPort = null;
+let isQuitting = false;
+let restartTimer = null;
+let suppressNextDashboardExitRestart = false;
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function statusHtml(title, detail) {
+    const safeTitle = title.replace(/[<&>]/g, '');
+    const safeDetail = detail.replace(/[<&>]/g, '');
+    return 'data:text/html;charset=utf-8,' + encodeURIComponent('<!doctype html><html><head><meta charset="utf-8">' +
+        '<style>body{margin:0;height:100vh;display:flex;align-items:center;justify-content:center;' +
+        'font-family:-apple-system,BlinkMacSystemFont,Segoe UI,sans-serif;background:#111827;color:#f9fafb}' +
+        '.box{max-width:520px;padding:28px;text-align:center}.title{font-size:22px;font-weight:700;margin-bottom:10px}' +
+        '.detail{font-size:13px;line-height:1.5;color:#cbd5e1}</style></head><body><div class="box">' +
+        '<div class="title">' + safeTitle + '</div><div class="detail">' + safeDetail + '</div>' +
+        '</div></body></html>');
+}
+function loadStatus(title, detail) {
+    if (!mainWindow)
+        return;
+    mainWindow.loadURL(statusHtml(title, detail)).catch(() => undefined);
+}
+function resolveIconPath(name) {
+    const electronProcess = process;
+    const packagedRoot = typeof electronProcess.resourcesPath === 'string'
+        ? path.join(electronProcess.resourcesPath, 'build', 'icons')
+        : ICONS_DIR;
+    const candidates = [
+        path.join(ICONS_DIR, name),
+        path.join(packagedRoot, name),
+    ];
+    return candidates.find((candidate) => existsSync(candidate)) ?? candidates[0];
+}
+function loadIcon(name) {
+    const icon = nativeImage.createFromPath(resolveIconPath(name));
+    return icon.isEmpty() ? nativeImage.createEmpty() : icon;
+}
+function probeDashboard(port) {
+    return new Promise((resolve) => {
+        const req = http.get({ hostname: '127.0.0.1', port, path: '/', timeout: 600 }, (res) => {
+            res.resume();
+            resolve(Boolean(res.statusCode && res.statusCode >= 200 && res.statusCode < 500));
+        });
+        req.on('timeout', () => {
+            req.destroy();
+            resolve(false);
+        });
+        req.on('error', () => resolve(false));
+    });
+}
+async function waitForDashboard(startPort, timeoutMs = 25_000) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (observedPort && await probeDashboard(observedPort))
+            return observedPort;
+        for (let port = startPort; port < startPort + 10; port++) {
+            if (await probeDashboard(port))
+                return port;
+        }
+        await sleep(400);
+    }
+    throw new Error(`Dashboard did not become ready on ports ${startPort}-${startPort + 9}`);
+}
+async function findRunningDashboard(startPort) {
+    if (observedPort && await probeDashboard(observedPort))
+        return observedPort;
+    for (let port = startPort; port < startPort + 10; port++) {
+        if (await probeDashboard(port))
+            return port;
+    }
+    return null;
+}
+function attachDashboardLogs(child) {
+    const onChunk = (chunk) => {
+        const text = chunk.toString();
+        const match = text.match(/http:\/\/localhost:(\d+)/);
+        if (match)
+            observedPort = Number(match[1]);
+        if (process.env.CLEMENTINE_DESKTOP_DEBUG === '1')
+            process.stdout.write(text);
+    };
+    child.stdout?.on('data', onChunk);
+    child.stderr?.on('data', (chunk) => {
+        if (process.env.CLEMENTINE_DESKTOP_DEBUG === '1')
+            process.stderr.write(chunk);
+    });
+}
+function startDashboardProcess(port) {
+    if (!existsSync(CLI_ENTRY)) {
+        throw new Error(`Missing ${CLI_ENTRY}. Run npm run build before starting the desktop app.`);
+    }
+    observedPort = null;
+    const child = spawn(NODE_BINARY, [CLI_ENTRY, 'dashboard', '-p', String(port)], {
+        cwd: PACKAGE_ROOT,
+        env: {
+            ...process.env,
+            CLEMENTINE_HOME: BASE_DIR,
+            CLEMENTINE_NO_OPEN: '1',
+            __CLEM_DASHBOARD_CHILD: '1',
+        },
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    attachDashboardLogs(child);
+    child.on('exit', () => {
+        if (dashboardProcess === child)
+            dashboardProcess = null;
+        if (suppressNextDashboardExitRestart) {
+            suppressNextDashboardExitRestart = false;
+            return;
+        }
+        if (!isQuitting)
+            scheduleDashboardRestart();
+    });
+    return child;
+}
+async function startDashboardAndLoad() {
+    if (restartTimer) {
+        clearTimeout(restartTimer);
+        restartTimer = null;
+    }
+    loadStatus('Opening Clementine', 'Looking for the local dashboard...');
+    try {
+        const existingPort = await findRunningDashboard(DEFAULT_PORT);
+        if (existingPort) {
+            dashboardUrl = `http://127.0.0.1:${existingPort}`;
+            await mainWindow.loadURL(dashboardUrl);
+            return;
+        }
+        loadStatus('Starting Clementine', 'Opening the local dashboard server...');
+        if (!dashboardProcess)
+            dashboardProcess = startDashboardProcess(DEFAULT_PORT);
+        const actualPort = await waitForDashboard(DEFAULT_PORT);
+        dashboardUrl = `http://127.0.0.1:${actualPort}`;
+        await mainWindow.loadURL(dashboardUrl);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        loadStatus('Clementine is offline', message);
+        dialog.showErrorBox('Clementine desktop failed to start', message);
+    }
+}
+function scheduleDashboardRestart() {
+    loadStatus('Reconnecting', 'The dashboard process stopped. Restarting it now...');
+    if (restartTimer)
+        clearTimeout(restartTimer);
+    restartTimer = setTimeout(() => {
+        restartTimer = null;
+        startDashboardAndLoad().catch(() => undefined);
+    }, 1200);
+}
+function stopDashboard(suppressRestart = true) {
+    if (!dashboardProcess)
+        return;
+    const child = dashboardProcess;
+    dashboardProcess = null;
+    suppressNextDashboardExitRestart = suppressRestart;
+    try {
+        child.kill('SIGTERM');
+    }
+    catch { /* ignore */ }
+}
+function restartDashboard() {
+    stopDashboard(true);
+    setTimeout(() => {
+        startDashboardAndLoad().catch(() => undefined);
+    }, 700);
+}
+function createWindow() {
+    mainWindow = new BrowserWindow({
+        width: 1280,
+        height: 860,
+        minWidth: 980,
+        minHeight: 680,
+        title: 'Clementine',
+        backgroundColor: '#111827',
+        icon: resolveIconPath('clementine.png'),
+        webPreferences: {
+            contextIsolation: true,
+            nodeIntegration: false,
+            sandbox: true,
+        },
+    });
+    mainWindow.on('close', (event) => {
+        if (isQuitting)
+            return;
+        event.preventDefault();
+        mainWindow.hide();
+    });
+    mainWindow.webContents.setWindowOpenHandler(({ url }) => {
+        shell.openExternal(url).catch(() => undefined);
+        return { action: 'deny' };
+    });
+}
+function showWindow() {
+    if (!mainWindow)
+        createWindow();
+    mainWindow.show();
+    mainWindow.focus();
+}
+function installMenu() {
+    const template = [
+        {
+            label: 'Clementine',
+            submenu: [
+                { label: 'Show Clementine', click: showWindow },
+                { label: 'Open in Browser', click: () => shell.openExternal(dashboardUrl).catch(() => undefined) },
+                {
+                    label: 'Restart Dashboard',
+                    click: restartDashboard,
+                },
+                { type: 'separator' },
+                {
+                    label: 'Quit Clementine',
+                    accelerator: 'CmdOrCtrl+Q',
+                    click: () => {
+                        isQuitting = true;
+                        app.quit();
+                    },
+                },
+            ],
+        },
+        {
+            label: 'View',
+            submenu: [
+                { role: 'reload' },
+                { role: 'toggleDevTools' },
+                { type: 'separator' },
+                { role: 'resetZoom' },
+                { role: 'zoomIn' },
+                { role: 'zoomOut' },
+            ],
+        },
+    ];
+    Menu.setApplicationMenu(Menu.buildFromTemplate(template));
+}
+function installTray() {
+    const trayIcon = loadIcon(process.platform === 'darwin' ? 'trayTemplate.png' : 'tray.png');
+    tray = new Tray(trayIcon.isEmpty() ? loadIcon('tray.png') : trayIcon);
+    tray.setToolTip('Clementine');
+    tray.setContextMenu(Menu.buildFromTemplate([
+        { label: 'Show Clementine', click: showWindow },
+        { label: 'Restart Dashboard', click: restartDashboard },
+        { type: 'separator' },
+        { label: 'Quit', click: () => { isQuitting = true; app.quit(); } },
+    ]));
+    tray.on('click', showWindow);
+}
+function installPermissions() {
+    session.defaultSession.setPermissionRequestHandler((webContents, permission, callback) => {
+        const url = webContents.getURL?.() || '';
+        const local = url.startsWith('http://127.0.0.1:') || url.startsWith('http://localhost:');
+        callback(local && (permission === 'media' || permission === 'microphone'));
+    });
+}
+if (!app.requestSingleInstanceLock()) {
+    app.quit();
+}
+else {
+    app.on('second-instance', () => showWindow());
+    app.whenReady().then(() => {
+        const appIcon = loadIcon('clementine.png');
+        if (!appIcon.isEmpty() && app.dock)
+            app.dock.setIcon(appIcon);
+        if (app.setAboutPanelOptions) {
+            app.setAboutPanelOptions({
+                applicationName: 'Clementine',
+                applicationVersion: app.getVersion(),
+                iconPath: resolveIconPath('clementine.png'),
+            });
+        }
+        installPermissions();
+        installMenu();
+        installTray();
+        createWindow();
+        startDashboardAndLoad().catch(() => undefined);
+    });
+}
+app.on('activate', () => showWindow());
+app.on('before-quit', () => {
+    isQuitting = true;
+    if (tray) {
+        try {
+            tray.destroy();
+        }
+        catch { /* ignore */ }
+    }
+    stopDashboard();
+});
+//# sourceMappingURL=main.js.map

package/dist/gateway/cron-scheduler.d.ts

@@ -128,6 +128,27 @@ export declare class CronScheduler {
      * verification is pending and DMs the verdict if so.
      */
     private _logRun;
+    /**
+     * Single source of truth for the NotificationContext attached to any
+     * dispatch that originated from a cron job. Threads `agentSlug` (so
+     * the channel layer routes via the owning hired agent's bot when one
+     * exists) and a deterministic `sessionKey` (so the inference safety
+     * net at the dispatcher can recover routing if a future caller drops
+     * `agentSlug`). Use this — never construct contexts inline — so new
+     * dispatch sites in this file can't silently leak hired-agent results
+     * into Clementine's main DM.
+     */
+    private dispatchContextForJob;
+    /**
+     * Variant for dispatch sites that only have the job name in scope
+     * (MCP triggers, fix-verification, anywhere downstream of the run
+     * loop). Looks up the owning agentSlug from the live job table —
+     * falling back to a name-only context when the job is unknown
+     * (e.g. one-shot triggers without a CRON.md entry).
+     */
+    private dispatchContextForJobName;
+    /** Same idea for workflows. Workflows can be agent-scoped via WorkflowDefinition.agentSlug. */
+    private dispatchContextForWorkflow;
     private runJob;
     /**
      * Log an advisor event to the events JSONL file for dashboard surfacing.

package/dist/gateway/cron-scheduler.js

@@ -729,10 +729,48 @@ export class CronScheduler {
     _logRun(entry) {
         this.runLog.append(entry);
         import('./fix-verification.js').then(({ checkAndDeliverVerification }) => {
-            checkAndDeliverVerification(entry, (text) => this.dispatcher.send(text, {}))
+            const ctx = this.dispatchContextForJobName(entry.jobName);
+            checkAndDeliverVerification(entry, (text) => this.dispatcher.send(text, ctx))
                 .catch(err => logger.warn({ err, job: entry.jobName }, 'Fix verification DM failed'));
         }).catch(err => logger.warn({ err }, 'Fix-verification import failed'));
     }
+    /**
+     * Single source of truth for the NotificationContext attached to any
+     * dispatch that originated from a cron job. Threads `agentSlug` (so
+     * the channel layer routes via the owning hired agent's bot when one
+     * exists) and a deterministic `sessionKey` (so the inference safety
+     * net at the dispatcher can recover routing if a future caller drops
+     * `agentSlug`). Use this — never construct contexts inline — so new
+     * dispatch sites in this file can't silently leak hired-agent results
+     * into Clementine's main DM.
+     */
+    dispatchContextForJob(job) {
+        const ctx = { sessionKey: `cron:${job.name}` };
+        if (job.agentSlug)
+            ctx.agentSlug = job.agentSlug;
+        return ctx;
+    }
+    /**
+     * Variant for dispatch sites that only have the job name in scope
+     * (MCP triggers, fix-verification, anywhere downstream of the run
+     * loop). Looks up the owning agentSlug from the live job table —
+     * falling back to a name-only context when the job is unknown
+     * (e.g. one-shot triggers without a CRON.md entry).
+     */
+    dispatchContextForJobName(jobName) {
+        const job = this.jobs.find(j => j.name === jobName);
+        if (job)
+            return this.dispatchContextForJob(job);
+        return { sessionKey: `cron:${jobName}` };
+    }
+    /** Same idea for workflows. Workflows can be agent-scoped via WorkflowDefinition.agentSlug. */
+    dispatchContextForWorkflow(name) {
+        const wf = this.workflowDefs.find(w => w.name === name);
+        const ctx = { sessionKey: `workflow:${name}` };
+        if (wf?.agentSlug)
+            ctx.agentSlug = wf.agentSlug;
+        return ctx;
+    }
     async runJob(job) {
         const creditBlock = getBackgroundCreditBlock();
         if (creditBlock) {
@@ -836,7 +874,7 @@ export class CronScheduler {
             await this.dispatcher.send(`**Cron job ready to run:** "${job.name}"\n` +
                 `Schedule: \`${job.schedule}\`\n\n` +
                 `Reply \`yes\` or \`go\` to proceed, \`no\` or \`skip\` to cancel. ` +
-                `Auto-runs in ${timeoutMin} min if no reply.`).catch(err => logger.debug({ err }, 'Failed to send cron confirmation request'));
+                `Auto-runs in ${timeoutMin} min if no reply.`, this.dispatchContextForJob(job)).catch(err => logger.debug({ err }, 'Failed to send cron confirmation request'));
             // Override gateway's default 5-min timeout with the job's configured timeout
             const approved = await new Promise((resolve) => {
                 const timer = setTimeout(() => {
@@ -1054,7 +1092,7 @@ export class CronScheduler {
                     if (response && !CronScheduler.isCronNoise(response)) {
                         // Strip internal thinking/process narration from Discord output
                         const cleanedResponse = CronScheduler.stripThinkingPrefixes(response);
-                        const result = await this.dispatcher.send(cleanedResponse, { agentSlug: job.agentSlug });
+                        const result = await this.dispatcher.send(cleanedResponse, this.dispatchContextForJob(job));
                         if (!result.delivered) {
                             entry.deliveryFailed = true;
                             entry.deliveryError = Object.values(result.channelErrors).join('; ').slice(0, 300);
@@ -1117,14 +1155,14 @@ export class CronScheduler {
                         const { block, created } = markBackgroundCreditBlocked(err);
                         logger.error({ err, job: job.name, until: block.until }, 'Cron hit Claude credit exhaustion — pausing background jobs');
                         if (created) {
-                            await this.dispatcher.send(`${job.name} hit Claude credit exhaustion. Background jobs are paused until ${block.until} so they stop draining/retrying. Interactive chat may also fail until credits are available.`, { agentSlug: job.agentSlug });
+                            await this.dispatcher.send(`${job.name} hit Claude credit exhaustion. Background jobs are paused until ${block.until} so they stop draining/retrying. Interactive chat may also fail until credits are available.`, this.dispatchContextForJob(job));
                         }
                         return;
                     }
                     // Permanent error — stop immediately
                     if (errorType === 'permanent') {
                         logger.error({ err, job: job.name }, `Cron job '${job.name}' permanent error — not retrying`);
-                        await this.dispatcher.send(`${job.name} failed: ${err}`, { agentSlug: job.agentSlug });
+                        await this.dispatcher.send(`${job.name} failed: ${err}`, this.dispatchContextForJob(job));
                         return;
                     }
                     // Transient — retry with backoff if attempts remain
@@ -1136,7 +1174,7 @@ export class CronScheduler {
                     else {
                         logger.error({ err, job: job.name }, `Cron job '${job.name}' failed after ${attempt} attempt(s)`);
                         this.logAutonomy('failed', job, { errorType, attempts: attempt, error: String(err).slice(0, 500) });
-                        await this.dispatcher.send(CronScheduler.formatCronError(job.name, err), { agentSlug: job.agentSlug });
+                        await this.dispatcher.send(CronScheduler.formatCronError(job.name, err), this.dispatchContextForJob(job));
                     }
                 }
             }
@@ -1173,14 +1211,14 @@ export class CronScheduler {
                 // Circuit breaker just engaged — notify
                 this.logAutonomy('circuit_breaker', job, { consecutiveErrors: consErrors });
                 this.logAdvisorEvent('circuit-breaker', job.name, `Circuit breaker engaged after ${consErrors} consecutive errors`);
-                this.dispatcher.send(`⚡ **Circuit breaker engaged** for \`${job.name}\` — ${consErrors} consecutive errors. Will retry in 1 hour.`, { agentSlug: job.agentSlug }).catch(err => logger.debug({ err }, 'Failed to send circuit breaker notification'));
+                this.dispatcher.send(`⚡ **Circuit breaker engaged** for \`${job.name}\` — ${consErrors} consecutive errors. Will retry in 1 hour.`, this.dispatchContextForJob(job)).catch(err => logger.debug({ err }, 'Failed to send circuit breaker notification'));
             }
             else if (consErrors >= 5) {
                 // Check if recovery probe just succeeded
                 const lastRun = this.runLog.readRecent(job.name, 1)[0];
                 if (lastRun && !isRunHealthFailure(lastRun)) {
                     this.logAdvisorEvent('circuit-recovery', job.name, `Circuit breaker recovered after ${consErrors} errors`);
-                    this.dispatcher.send(`✅ **Circuit breaker recovered** — \`${job.name}\` succeeded after ${consErrors} prior errors.`, { agentSlug: job.agentSlug }).catch(err => logger.debug({ err }, 'Failed to send circuit recovery notification'));
+                    this.dispatcher.send(`✅ **Circuit breaker recovered** — \`${job.name}\` succeeded after ${consErrors} prior errors.`, this.dispatchContextForJob(job)).catch(err => logger.debug({ err }, 'Failed to send circuit recovery notification'));
                 }
             }
             if (advice.shouldEscalate) {
@@ -1223,7 +1261,7 @@ export class CronScheduler {
                 logger.error({ job: job.name, consErrors }, `Auto-disabled cron after ${consErrors} consecutive failures`);
                 this.logAutonomy('auto_disabled', job, { consecutiveErrors: consErrors });
                 this.logAdvisorEvent('auto-disabled', job.name, `Auto-disabled after ${consErrors} consecutive failures`);
-                this.dispatcher.send(`🛑 **Cron auto-disabled** — \`${job.name}\` failed ${consErrors} times in a row. Fix the job and re-enable it from the dashboard.`, { agentSlug: job.agentSlug }).catch(err => logger.debug({ err }, 'Failed to send auto-disable notification'));
+                this.dispatcher.send(`🛑 **Cron auto-disabled** — \`${job.name}\` failed ${consErrors} times in a row. Fix the job and re-enable it from the dashboard.`, this.dispatchContextForJob(job)).catch(err => logger.debug({ err }, 'Failed to send auto-disable notification'));
             }
         }
     }
@@ -1687,7 +1725,10 @@ export class CronScheduler {
                 logger.info({ jobName }, 'Processing MCP trigger for cron job');
                 this.runManual(jobName).then((result) => {
                     if (result && !result.includes('not found')) {
-                        this.dispatcher.send(`🔧 **${jobName}** (triggered):\n\n${result.slice(0, 1500)}`).catch(err => logger.debug({ err }, 'Failed to send trigger result notification'));
+                        // Route via the owning hired agent's bot when one exists —
+                        // otherwise this triggered-result message was leaking out
+                        // through Clementine's main DM (the bug from 1.18.60 → 1.18.61).
+                        this.dispatcher.send(`🔧 **${jobName}** (triggered):\n\n${result.slice(0, 1500)}`, this.dispatchContextForJobName(jobName)).catch(err => logger.debug({ err }, 'Failed to send trigger result notification'));
                     }
                 }).catch((err) => {
                     logger.error({ err, jobName }, 'Trigger-initiated job failed');
@@ -2040,7 +2081,7 @@ export class CronScheduler {
             logger.info({ workflow: name, inputs }, `Running workflow: ${name}`);
             const response = await this.gateway.handleWorkflow(wf, inputs ?? {});
             if (response && response !== '*(workflow completed — no output)*') {
-                await this.dispatcher.send(`**[Workflow: ${name}]**\n\n${response.slice(0, 1500)}`);
+                await this.dispatcher.send(`**[Workflow: ${name}]**\n\n${response.slice(0, 1500)}`, this.dispatchContextForWorkflow(name));
                 // Inject into owner's DM session
                 if (DISCORD_OWNER_ID && DISCORD_OWNER_ID !== '0') {
                     this.gateway.injectContext(`discord:user:${DISCORD_OWNER_ID}`, `[Workflow: ${name}]`, response);
@@ -2053,7 +2094,7 @@ export class CronScheduler {
         catch (err) {
             logger.error({ err, workflow: name }, `Workflow '${name}' failed`);
             const errMsg = `Workflow '${name}' failed: ${String(err).slice(0, 300)}`;
-            await this.dispatcher.send(errMsg);
+            await this.dispatcher.send(errMsg, this.dispatchContextForWorkflow(name));
             return errMsg;
         }
         finally {

package/dist/gateway/notifications.d.ts

@@ -6,6 +6,30 @@
  * the dispatcher fans out notifications to all registered channels.
  */
 import type { NotificationSender, NotificationContext } from '../types.js';
+/**
+ * Recover the owning hired-agent slug from a session key when the
+ * caller forgot to set `context.agentSlug` explicitly. Pure pattern
+ * matching — no I/O, no registry lookups — so it's cheap to run on
+ * every send. Catches the most common autonomous-path key shapes:
+ *
+ *   heartbeat:<slug>            → <slug>
+ *   agent-heartbeat:<slug>      → <slug>
+ *   team-task:<from>-><to>      → <to>   (the receiving agent owns the result)
+ *   discord:agent:<slug>:*      → <slug>
+ *   discord:member:*:<slug>:*   → <slug>
+ *   discord:member-dm:<slug>:*  → <slug>
+ *
+ * The cron path uses `cron:<jobName>` which deliberately does NOT
+ * encode the agent slug — cron-scheduler.ts threads `agentSlug`
+ * explicitly via `dispatchContextForJob()` instead.
+ *
+ * Returns undefined for keys that look like a Clementine-owned path
+ * (slug === 'clementine', no slug encoded, etc.) — the channel layer
+ * then routes through Clementine's main bot, which is correct.
+ *
+ * Exported so tests can pin the contract.
+ */
+export declare function inferAgentSlugFromSessionKey(sessionKey: string): string | undefined;
 export interface SendResult {
     delivered: boolean;
     channelErrors: Record<string, string>;

package/dist/gateway/notifications.js

@@ -25,12 +25,81 @@ function channelForSessionKey(sessionKey) {
         return 'dashboard';
     return null;
 }
+/**
+ * Recover the owning hired-agent slug from a session key when the
+ * caller forgot to set `context.agentSlug` explicitly. Pure pattern
+ * matching — no I/O, no registry lookups — so it's cheap to run on
+ * every send. Catches the most common autonomous-path key shapes:
+ *
+ *   heartbeat:<slug>            → <slug>
+ *   agent-heartbeat:<slug>      → <slug>
+ *   team-task:<from>-><to>      → <to>   (the receiving agent owns the result)
+ *   discord:agent:<slug>:*      → <slug>
+ *   discord:member:*:<slug>:*   → <slug>
+ *   discord:member-dm:<slug>:*  → <slug>
+ *
+ * The cron path uses `cron:<jobName>` which deliberately does NOT
+ * encode the agent slug — cron-scheduler.ts threads `agentSlug`
+ * explicitly via `dispatchContextForJob()` instead.
+ *
+ * Returns undefined for keys that look like a Clementine-owned path
+ * (slug === 'clementine', no slug encoded, etc.) — the channel layer
+ * then routes through Clementine's main bot, which is correct.
+ *
+ * Exported so tests can pin the contract.
+ */
+export function inferAgentSlugFromSessionKey(sessionKey) {
+    const heartbeatMatch = /^(?:agent-)?heartbeat:([^:]+)$/.exec(sessionKey);
+    if (heartbeatMatch && heartbeatMatch[1] !== 'clementine') {
+        return heartbeatMatch[1];
+    }
+    const teamTaskMatch = /^team-task:[^:]+->([^:]+)$/.exec(sessionKey);
+    if (teamTaskMatch && teamTaskMatch[1] !== 'clementine') {
+        return teamTaskMatch[1];
+    }
+    const discordAgentMatch = /^discord:agent:([^:]+):/.exec(sessionKey);
+    if (discordAgentMatch && discordAgentMatch[1] !== 'clementine') {
+        return discordAgentMatch[1];
+    }
+    const memberDmMatch = /^discord:member-dm:([^:]+):/.exec(sessionKey);
+    if (memberDmMatch && memberDmMatch[1] !== 'clementine') {
+        return memberDmMatch[1];
+    }
+    // discord:member:<channelId>:<slug>:<userId>
+    const memberMatch = /^discord:member:[^:]+:([^:]+):/.exec(sessionKey);
+    if (memberMatch && memberMatch[1] !== 'clementine') {
+        return memberMatch[1];
+    }
+    return undefined;
+}
+/**
+ * Fill in `context.agentSlug` from `context.sessionKey` when the
+ * caller didn't set it. Pure, side-effect-free; returns the original
+ * context unchanged when nothing can be inferred.
+ *
+ * Centralised so both the public `send()` entrypoint AND the retry
+ * queue's `sendDirect` go through it — a request that falls into the
+ * retry queue without an explicit agentSlug must not lose its routing
+ * the second time around either.
+ */
+function enrichContext(context) {
+    if (!context)
+        return context;
+    if (context.agentSlug)
+        return context;
+    if (!context.sessionKey)
+        return context;
+    const inferred = inferAgentSlugFromSessionKey(context.sessionKey);
+    if (!inferred)
+        return context;
+    return { ...context, agentSlug: inferred };
+}
 export class NotificationDispatcher {
     senders = new Map();
     _retryQueue;
     constructor() {
         this._retryQueue = new DeliveryQueue();
-        this._retryQueue.setSender((text, ctx) => this.sendDirect(text, ctx));
+        this._retryQueue.setSender((text, ctx) => this.sendDirect(text, enrichContext(ctx)));
         this._retryQueue.start();
     }
     register(channelName, senderFn) {
@@ -59,7 +128,16 @@ export class NotificationDispatcher {
         if (redactionStats.redactionCount > 0) {
             logger.warn({ count: redactionStats.redactionCount, labels: redactionStats.labelsHit, sessionKey: context?.sessionKey }, `Redacted ${redactionStats.redactionCount} credential-shaped value(s) before delivery`);
         }
-        const result = await this.sendDirect(redacted, context);
+        // Defense-in-depth: if a caller forgot `agentSlug` but their
+        // sessionKey encodes a hired agent (heartbeat/team-task/discord
+        // member sessions), recover it here so the channel layer routes
+        // through that agent's bot instead of leaking out via Clementine's
+        // main DM. Explicit `agentSlug` always wins.
+        const enriched = enrichContext(context);
+        if (!context?.agentSlug && enriched?.agentSlug) {
+            logger.debug({ sessionKey: context?.sessionKey, inferredAgentSlug: enriched.agentSlug }, 'Inferred agentSlug from sessionKey for routing');
+        }
+        const result = await this.sendDirect(redacted, enriched);
         // If delivery failed and there were actual senders (not "no channels"), queue for retry.
         // Stored text is already-redacted so disk persistence never holds a credential.
         if (!result.delivered && this.senders.size > 0) {

package/dist/memory/store.js

@@ -474,6 +474,19 @@ export class MemoryStore {
       CREATE INDEX IF NOT EXISTS idx_memory_events_created
         ON memory_events(created_at DESC);
     `);
+        try {
+            this.conn.exec('ALTER TABLE memory_events ADD COLUMN indexed_at TEXT');
+        }
+        catch {
+            // Column already exists. Older installs created memory_events before
+            // indexed_at was added; keep the health dashboard schema-compatible.
+        }
+        try {
+            this.conn.exec('ALTER TABLE memory_events ADD COLUMN created_at TEXT');
+        }
+        catch {
+            // Column already exists
+        }
         this.conn.exec(`
       CREATE TABLE IF NOT EXISTS memory_promotion_candidates (
         id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -3888,7 +3901,14 @@ export class MemoryStore {
     }
     getMemoryEventStats() {
         const total = this.conn.prepare('SELECT COUNT(*) AS c FROM memory_events').get().c;
-        const indexed = this.conn.prepare('SELECT COUNT(*) AS c FROM memory_events WHERE indexed_at IS NOT NULL').get().c;
+        let indexed = total;
+        try {
+            indexed = this.conn.prepare('SELECT COUNT(*) AS c FROM memory_events WHERE indexed_at IS NOT NULL').get().c;
+        }
+        catch {
+            // Pre-indexed_at ledgers were all written as proof of indexing.
+            indexed = total;
+        }
         const bySourceType = this.conn
             .prepare(`SELECT source_type AS sourceType, COUNT(*) AS count
                 FROM memory_events GROUP BY source_type ORDER BY count DESC`)

package/dist/voice/gemini-live.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Gemini Live voice relay.
+ *
+ * The browser/Electron renderer connects to this local WebSocket. The relay
+ * owns the Google API key and forwards raw PCM audio to Gemini Live over the
+ * upstream WebSocket API.
+ */
+import type http from 'node:http';
+export type GeminiLiveStatus = {
+    enabled: boolean;
+    provider: string;
+    configured: boolean;
+    available: boolean;
+    model: string;
+    voiceName: string;
+    reason?: string;
+};
+export type GeminiLiveRelayHandle = {
+    available: boolean;
+    close: () => void;
+};
+export type GeminiLiveRelayOptions = {
+    isTokenValid: (token: string) => boolean;
+};
+type GeminiSetupOptions = {
+    model?: string;
+    voiceName?: string;
+    systemInstruction?: string;
+};
+export declare function buildGeminiLiveSetup(opts?: GeminiSetupOptions): Record<string, unknown>;
+export declare function getGeminiLiveStatus(): GeminiLiveStatus;
+export declare function installGeminiLiveRelay(server: http.Server, opts: GeminiLiveRelayOptions): GeminiLiveRelayHandle;
+export {};
+//# sourceMappingURL=gemini-live.d.ts.map

package/dist/voice/gemini-live.js

@@ -0,0 +1,263 @@
+/**
+ * Gemini Live voice relay.
+ *
+ * The browser/Electron renderer connects to this local WebSocket. The relay
+ * owns the Google API key and forwards raw PCM audio to Gemini Live over the
+ * upstream WebSocket API.
+ */
+import { createRequire } from 'node:module';
+import { URL } from 'node:url';
+import pino from 'pino';
+import { GEMINI_API_KEY, GEMINI_LIVE_MODEL, GEMINI_LIVE_VOICE_NAME, VOICE_ENABLED, VOICE_PROVIDER, } from '../config.js';
+const logger = pino({ name: 'clementine.gemini-live' });
+const require = createRequire(import.meta.url);
+const GEMINI_WS_URL = 'wss://generativelanguage.googleapis.com/ws/google.ai.generativelanguage.v1beta.GenerativeService.BidiGenerateContent';
+const WS_OPEN = 1;
+function runtimeValue(key, fallback = '') {
+    return String(process.env[key] ?? fallback ?? '').trim();
+}
+function currentApiKey() {
+    return runtimeValue('GEMINI_API_KEY', GEMINI_API_KEY) || runtimeValue('GOOGLE_API_KEY');
+}
+function currentModel() {
+    return runtimeValue('GEMINI_LIVE_MODEL', GEMINI_LIVE_MODEL) || 'gemini-3.1-flash-live-preview';
+}
+function currentVoiceName() {
+    return runtimeValue('GEMINI_LIVE_VOICE_NAME', GEMINI_LIVE_VOICE_NAME) || 'Kore';
+}
+function currentVoiceProvider() {
+    return runtimeValue('VOICE_PROVIDER', VOICE_PROVIDER) || 'gemini-live';
+}
+function currentVoiceEnabled() {
+    return runtimeValue('VOICE_ENABLED', String(VOICE_ENABLED)).toLowerCase() !== 'false';
+}
+function loadWs() {
+    try {
+        return require('ws');
+    }
+    catch (err) {
+        logger.warn({ err }, 'ws package is not available; Gemini Live relay disabled');
+        return null;
+    }
+}
+function stripModelsPrefix(model) {
+    return model.replace(/^models\//, '').trim();
+}
+export function buildGeminiLiveSetup(opts = {}) {
+    const model = stripModelsPrefix(opts.model || currentModel());
+    const voiceName = opts.voiceName || currentVoiceName();
+    const systemInstruction = opts.systemInstruction
+        || 'You are Clementine, a concise voice assistant. Keep spoken replies brief and conversational unless the user asks for detail.';
+    const config = {
+        model: `models/${model}`,
+        responseModalities: ['AUDIO'],
+        inputAudioTranscription: {},
+        outputAudioTranscription: {},
+        systemInstruction: {
+            parts: [{ text: systemInstruction }],
+        },
+    };
+    if (voiceName) {
+        config.speechConfig = {
+            voiceConfig: {
+                prebuiltVoiceConfig: { voiceName },
+            },
+        };
+    }
+    return { config };
+}
+export function getGeminiLiveStatus() {
+    const enabled = currentVoiceEnabled();
+    const provider = currentVoiceProvider();
+    const configured = Boolean(currentApiKey());
+    const wsAvailable = Boolean(loadWs());
+    const available = enabled && provider === 'gemini-live' && configured && wsAvailable;
+    const reason = !enabled
+        ? 'VOICE_ENABLED=false'
+        : provider !== 'gemini-live'
+            ? `VOICE_PROVIDER=${provider}`
+            : !configured
+                ? 'Set GEMINI_API_KEY or GOOGLE_API_KEY'
+                : !wsAvailable
+                    ? 'Install ws'
+                    : undefined;
+    return {
+        enabled,
+        provider,
+        configured,
+        available,
+        model: currentModel(),
+        voiceName: currentVoiceName(),
+        ...(reason ? { reason } : {}),
+    };
+}
+function sendJson(ws, payload) {
+    if (ws.readyState !== WS_OPEN)
+        return;
+    try {
+        ws.send(JSON.stringify(payload));
+    }
+    catch (err) {
+        logger.debug({ err }, 'Gemini Live client send failed');
+    }
+}
+function closeSocket(ws, code = 1000, reason = 'closed') {
+    if (!ws)
+        return;
+    try {
+        ws.close(code, reason);
+    }
+    catch {
+        try {
+            ws.terminate?.();
+        }
+        catch { /* ignore */ }
+    }
+}
+function connectGemini(wsMod, client, query) {
+    const apiKey = currentApiKey();
+    if (!apiKey) {
+        sendJson(client, { type: 'error', error: 'Gemini Live is not configured. Set GEMINI_API_KEY or GOOGLE_API_KEY.' });
+        closeSocket(client, 1011, 'Gemini API key missing');
+        return null;
+    }
+    const upstreamUrl = `${GEMINI_WS_URL}?key=${encodeURIComponent(apiKey)}`;
+    const upstream = new wsMod.WebSocket(upstreamUrl);
+    const pending = [];
+    let upstreamOpen = false;
+    const flush = () => {
+        if (!upstreamOpen || upstream.readyState !== WS_OPEN)
+            return;
+        while (pending.length > 0)
+            upstream.send(pending.shift());
+    };
+    const sendUpstream = (payload) => {
+        const text = JSON.stringify(payload);
+        if (upstreamOpen && upstream.readyState === WS_OPEN)
+            upstream.send(text);
+        else
+            pending.push(text);
+    };
+    upstream.on('open', () => {
+        upstreamOpen = true;
+        const setup = buildGeminiLiveSetup({
+            model: query.get('model') || undefined,
+            voiceName: query.get('voice') || undefined,
+        });
+        upstream.send(JSON.stringify(setup));
+        flush();
+        sendJson(client, { type: 'ready', model: currentModel(), voiceName: currentVoiceName() });
+    });
+    upstream.on('message', (data) => {
+        let response;
+        try {
+            response = JSON.parse(String(data));
+        }
+        catch {
+            sendJson(client, { type: 'raw', data: String(data) });
+            return;
+        }
+        const content = response.serverContent;
+        if (content?.modelTurn?.parts) {
+            for (const part of content.modelTurn.parts) {
+                const inline = part.inlineData;
+                if (inline?.data) {
+                    sendJson(client, {
+                        type: 'audio',
+                        data: inline.data,
+                        mimeType: inline.mimeType || 'audio/pcm;rate=24000',
+                    });
+                }
+            }
+        }
+        if (content?.inputTranscription?.text) {
+            sendJson(client, { type: 'transcript', role: 'user', text: content.inputTranscription.text });
+        }
+        if (content?.outputTranscription?.text) {
+            sendJson(client, { type: 'transcript', role: 'assistant', text: content.outputTranscription.text });
+        }
+        if (content?.interrupted) {
+            sendJson(client, { type: 'interrupted' });
+        }
+        if (content?.turnComplete) {
+            sendJson(client, { type: 'turn_complete' });
+        }
+        if (response.toolCall) {
+            sendJson(client, { type: 'tool_call', toolCall: response.toolCall });
+        }
+        sendJson(client, { type: 'event', event: response });
+    });
+    upstream.on('error', (err) => {
+        logger.warn({ err }, 'Gemini Live upstream error');
+        sendJson(client, { type: 'error', error: err.message || String(err) });
+    });
+    upstream.on('close', (code, reason) => {
+        sendJson(client, { type: 'closed', code, reason: reason?.toString?.() || '' });
+        closeSocket(client, 1000, 'Gemini Live upstream closed');
+    });
+    client.on('message', (data) => {
+        let message;
+        try {
+            message = JSON.parse(String(data));
+        }
+        catch {
+            sendJson(client, { type: 'error', error: 'Invalid voice message JSON' });
+            return;
+        }
+        if (message.type === 'audio' && message.data) {
+            sendUpstream({
+                realtimeInput: {
+                    audio: {
+                        data: String(message.data),
+                        mimeType: String(message.mimeType || 'audio/pcm;rate=16000'),
+                    },
+                },
+            });
+        }
+        else if (message.type === 'text' && message.text) {
+            sendUpstream({ realtimeInput: { text: String(message.text) } });
+        }
+        else if (message.type === 'audio_stream_end' || message.type === 'stop') {
+            sendUpstream({ realtimeInput: { audioStreamEnd: true } });
+        }
+    });
+    client.on('close', () => closeSocket(upstream));
+    client.on('error', () => closeSocket(upstream));
+    return upstream;
+}
+export function installGeminiLiveRelay(server, opts) {
+    const wsMod = loadWs();
+    if (!wsMod)
+        return { available: false, close: () => undefined };
+    const wss = new wsMod.WebSocketServer({ noServer: true, maxPayload: 2 * 1024 * 1024 });
+    wss.on('connection', (client, req) => {
+        const url = new URL(req.url || '/', 'http://127.0.0.1');
+        connectGemini(wsMod, client, url.searchParams);
+    });
+    server.on('upgrade', (req, socket, head) => {
+        const url = new URL(req.url || '/', 'http://127.0.0.1');
+        if (url.pathname !== '/api/voice/live/ws')
+            return;
+        const token = url.searchParams.get('token') || '';
+        const status = getGeminiLiveStatus();
+        if (!opts.isTokenValid(token)) {
+            socket.write('HTTP/1.1 401 Unauthorized\r\n\r\n');
+            socket.destroy();
+            return;
+        }
+        if (!status.available) {
+            socket.write(`HTTP/1.1 503 Service Unavailable\r\n\r\n${status.reason || 'Gemini Live unavailable'}`);
+            socket.destroy();
+            return;
+        }
+        wss.handleUpgrade(req, socket, head, (ws) => {
+            wss.emit('connection', ws, req);
+        });
+    });
+    logger.info('Gemini Live relay attached to dashboard server');
+    return {
+        available: true,
+        close: () => wss.close(),
+    };
+}
+//# sourceMappingURL=gemini-live.js.map

package/electron-builder.yml

@@ -0,0 +1,34 @@
+appId: com.clementine.assistant
+productName: Clementine
+asar: false
+npmRebuild: false
+directories:
+  buildResources: build
+  output: release
+extraMetadata:
+  main: dist/desktop/main.js
+files:
+  - dist/**/*
+  - build/icons/*.png
+  - build/icons/*.icns
+  - package.json
+  - README.md
+  - scripts/**/*
+  - vendor/**/*
+extraResources:
+  - from: build/icons
+    to: build/icons
+    filter:
+      - '*.png'
+      - '*.icns'
+mac:
+  category: public.app-category.productivity
+  icon: build/icons/icon.icns
+  target:
+    - dmg
+    - zip
+artifactName: Clementine-${version}-mac-${arch}.${ext}
+publish:
+  provider: github
+  owner: Natebreynolds
+  repo: Clementine-AI-Assistant

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clementine-agent",
-  "version": "1.18.61",
+  "version": "1.18.63",
   "description": "Clementine — Personal AI Assistant (TypeScript)",
   "type": "module",
   "main": "dist/index.js",
@@ -13,6 +13,12 @@
     "prepublishOnly": "npm run build && find dist -name '*.map' -delete",
     "dev": "tsx src/index.ts",
     "start": "node dist/index.js",
+    "dashboard": "npm run build && node dist/cli/index.js dashboard",
+    "desktop": "npm run build && electron dist/desktop/main.js",
+    "desktop:debug": "npm run build && CLEMENTINE_DESKTOP_DEBUG=1 electron dist/desktop/main.js",
+    "desktop:prepare": "npm run build && npm rebuild better-sqlite3",
+    "desktop:pack": "npm run desktop:prepare && electron-builder --mac --dir",
+    "desktop:dist": "npm run desktop:prepare && electron-builder --mac",
     "mcp": "tsx src/tools/mcp-server.ts",
     "cli": "tsx src/cli/index.ts",
     "typecheck": "tsc --noEmit",
@@ -47,6 +53,7 @@
     "pdf-parse": "^1.1.1",
     "pino": "^9.6.0",
     "twilio": "^5.5.0",
+    "ws": "^8.19.0",
     "zod": "^4.3.6"
   },
   "devDependencies": {
@@ -57,6 +64,8 @@
     "@types/node": "^22.12.0",
     "@types/node-cron": "^3.0.11",
     "@types/pdf-parse": "^1.1.4",
+    "electron": "^42.0.0",
+    "electron-builder": "^26.8.1",
     "tsx": "^4.19.0",
     "typescript": "^5.7.0",
     "vitest": "^4.1.1"
@@ -89,6 +98,8 @@
     "vault/",
     "scripts/",
     "vendor/",
+    "build/icons/",
+    "electron-builder.yml",
     "install.sh",
     "README.md",
     ".env.example"