feat: serveur MCP, heures calmes, mode mission, widget glanceable, barge-in (v2.4.0) (#14)

Serveur MCP local
- Endpoint /mcp (JSON-RPC 2.0, Streamable HTTP, réponses JSON) sur le serveur
  webhook : initialize, tools/list, tools/call, ping. Même secret que le
  webhook. 14 outils : capture_screen (image MCP), lock_session, open_app,
  open_url, media_key, clipboard_get/set, find_files, speak_text,
  notify_user, set_hud_state, get_app_status, get_conversation_history,
  show_message. Les outils UI transitent par IPC vers le renderer.
- Les mêmes actions système sont proposées au modèle en chat completions.

Notifications
- Heures calmes (plage horaire, franchissement de minuit), mots prioritaires,
  échecs de crons toujours lus, résumé vocal des messages entrants (n premières
  phrases), thème nuit automatique, compteur de non-lus.

Conversation
- Mode mission : bouton dans la barre de commande, second modèle Hermes
  (hermes.missionModel) pour les tâches longues.
- Barge-in : la parole de l'utilisateur coupe la voix ; seuil d'énergie et
  ratio relevés pendant la synthèse pour ignorer l'écho.

Widget compact
- Bandeau glanceable : état, dernière phrase, non-lus, indicateurs heures
  calmes et mission.

Tests : 28 tests unitaires (heures calmes, priorité, résumé), e2e Electron
sous Xvfb : MCP initialize/tools/list/tools/call (presse-papiers, capture en
image, état et message via le renderer), bandeau compact, aucune erreur.


Claude-Session: https://claude.ai/code/session_017Wn5VX9HNbJ7N54hR24u9Y

Co-authored-by: Claude <noreply@anthropic.com>

src/App.tsx

@@ -3,7 +3,9 @@ import { AlertTriangle, X } from 'lucide-react';
 import type { WindowMode } from '../shared/ipc';
 import { bridge } from './lib/bridge';
 import { Log } from './lib/log';
-import { handlePush, stopGeneration } from './services/conversation';
+import { handlePush, localToolContext, stopGeneration } from './services/conversation';
+import { initMcpBridge } from './services/mcpBridge';
+import { isQuietTime } from './lib/quietHours';
 import { speech } from './services/voice/speech';
 import { voiceController } from './services/voice/voiceController';
 import { useChat } from './state/chat';
@@ -57,6 +59,7 @@ function useBoot(): boolean {
           })
         );
         disposers.push(api.hermes.onPush(handlePush));
+        initMcpBridge(localToolContext);
         disposers.push(
           api.hotkeys.on((event) => {
             if (event === 'ptt-toggle') voiceController.toggle();
@@ -95,6 +98,24 @@ function useBoot(): boolean {
 function useThemeSync(): void {
   const theme = useSettings((s) => s.settings.theme);
   const reduce = useSettings((s) => s.settings.ui.reduceMotion);
+  // Quiet hours: computed every 30 s; dims the HUD (night theme) and silences pushes.
+  const notif = useSettings((s) => s.settings.notifications);
+  useEffect(() => {
+    const tick = () => {
+      const quiet = notif.quietEnabled && isQuietTime(notif.quietStart, notif.quietEnd);
+      useChat.getState().setQuiet(quiet);
+      document.documentElement.toggleAttribute('data-night', quiet && notif.nightTheme);
+    };
+    tick();
+    const timer = setInterval(tick, 30_000);
+    return () => clearInterval(timer);
+  }, [notif]);
+  useEffect(() => {
+    const onVisible = () => { if (!document.hidden) useChat.getState().markRead(); };
+    document.addEventListener('visibilitychange', onVisible);
+    return () => document.removeEventListener('visibilitychange', onVisible);
+  }, []);
+
   useEffect(() => {
     document.documentElement.dataset.theme = theme;
     document.documentElement.dataset.motion = reduce ? 'reduce' : 'full';

src/components/chat/CommandBar.tsx

@@ -1,5 +1,5 @@
 import { useEffect, useRef, useState } from 'react';
-import { Mic, Paperclip, Send, Square, X, Radio, Loader2, Volume2, VolumeX, Navigation, ScanEye } from 'lucide-react';
+import { Mic, Paperclip, Send, Square, X, Radio, Loader2, Volume2, VolumeX, Navigation, ScanEye, Crosshair } from 'lucide-react';
 import { sendMessage, steer, stopGeneration , captureScreen } from '../../services/conversation';
 import { speech } from '../../services/voice/speech';
 import { voiceController } from '../../services/voice/voiceController';
@@ -50,6 +50,8 @@ export function CommandBar({ compact }: Props) {
   const autoSpeak = useSettings((s) => s.settings.speech.autoSpeak);
   const update = useSettings((s) => s.update);
   const [images, setImages] = useState<string[]>([]);
+  const missionMode = useChat((s) => s.missionMode);
+  const missionModel = useSettings((s) => s.settings.hermes.missionModel);
   const [steerMode, setSteerMode] = useState(false);
   const fileRef = useRef<HTMLInputElement>(null);
   const inputRef = useRef<HTMLTextAreaElement>(null);
@@ -198,6 +200,9 @@ export function CommandBar({ compact }: Props) {
           <button className={`toggle-btn${handsFree ? ' on' : ''}`} onClick={() => voiceController.setHandsFree(!handsFree)} title="Écoute continue : le micro se réactive après chaque réponse">
             <Radio size={12} /> mains libres
           </button>
+          <button className={`toggle-btn${missionMode ? ' on' : ''}`} onClick={() => useChat.getState().setMissionMode(!missionMode)} title={missionModel ? `Mode mission : modèle ${missionModel} pour les tâches longues` : 'Mode mission (définissez un modèle « mission » dans Paramètres → Hermes)'}>
+            <Crosshair size={14} /> Mission
+          </button>
           <button className={`toggle-btn${autoSpeak && speechProvider !== 'off' ? ' on' : ''}`} onClick={() => update({ speech: { autoSpeak: !autoSpeak } })} title="Lire les réponses à voix haute">
             {autoSpeak && speechProvider !== 'off' ? <Volume2 size={12} /> : <VolumeX size={12} />} voix
           </button>

src/components/compact/CompactWidget.tsx

@@ -1,13 +1,37 @@
-import { Maximize2, X, Minus } from 'lucide-react';
+import { Maximize2, X, Minus, Moon, Crosshair } from 'lucide-react';
+import { useShallow } from 'zustand/react/shallow';
 import { bridge } from '../../lib/bridge';
 import { useSettings } from '../../state/settings';
+import { useChat } from '../../state/chat';
+import { useVoice } from '../../state/voice';
 import { CoreStage } from '../hud/CoreStage';
 import { ChatPanel } from '../chat/ChatPanel';
 
+const STATE_LABEL: Record<string, string> = {
+  idle: 'veille',
+  listening: 'écoute',
+  thinking: 'réflexion',
+  speaking: 'parle',
+  alert: 'alerte',
+  error: 'erreur',
+  success: 'terminé'
+};
+
+/** Compact mode: a glanceable strip (state, unread, last sentence) above the mini chat. */
 export function CompactWidget() {
   const assistantName = useSettings((s) => s.settings.assistantName);
   const compactOpacity = useSettings((s) => s.settings.ui.compactOpacity);
+  const { hud, hudOverride, unread, missionMode, quiet, last } = useChat(
+    useShallow((s) => {
+      const lastAssistant = [...s.messages].reverse().find((m) => m.role === 'assistant' && m.content.trim());
+      return { hud: s.hud, hudOverride: s.hudOverride, unread: s.unread, missionMode: s.missionMode, quiet: s.quiet, last: lastAssistant?.content ?? '' };
+    })
+  );
+  const wake = useVoice((s) => s.wake);
   const api = bridge();
+  const state = hudOverride ?? hud;
+  const label = state === 'idle' && wake === 'spotting' ? 'à l’écoute du mot-clé' : STATE_LABEL[state] ?? state;
+  const sentence = last.replace(/```[\s\S]*?```/g, ' ').replace(/[#*_>`|]/g, '').replace(/\s+/g, ' ').trim().slice(0, 140);
   return (
     <div className="compact-root" style={{ ['--compact-opacity' as string]: compactOpacity }}>
       <div className="compact-head">
@@ -21,6 +45,15 @@ export function CompactWidget() {
         )}
       </div>
       <CoreStage compact />
+      <div className="compact-glance" onClick={() => useChat.getState().markRead()} title={sentence}>
+        <span className={`state${state === 'alert' || state === 'error' ? ' alert' : ''}`}>{label}</span>
+        <span className="last">{sentence || 'Aucun message pour l’instant.'}</span>
+        <span className="badges">
+          {missionMode && <Crosshair size={12} className="mission" aria-label="mode mission" />}
+          {quiet && <Moon size={12} aria-label="heures calmes" />}
+          {unread > 0 && <span className="unread" aria-label={`${unread} non lus`}>{unread}</span>}
+        </span>
+      </div>
       <div className="compact-body">
         <ChatPanel compact />
       </div>

src/components/settings/SettingsDrawer.tsx

@@ -13,7 +13,7 @@ import { useVoice } from '../../state/voice';
 import { installedModels, useVoiceModels } from '../../state/voiceModels';
 import { ModelsSection } from './ModelsSection';
 
-type Section = 'general' | 'hermes' | 'voice' | 'speech' | 'models' | 'webhook' | 'ui';
+type Section = 'general' | 'hermes' | 'voice' | 'speech' | 'models' | 'webhook' | 'notifications' | 'ui';
 
 interface Props {
   onClose: () => void;
@@ -151,6 +151,7 @@ export function SettingsDrawer({ onClose }: Props) {
     ['speech', 'Voix / TTS'],
     ['models', 'Modèles locaux'],
     ['webhook', 'Webhook'],
+    ['notifications', 'Notifications'],
     ['general', 'Général'],
     ['ui', 'Interface']
   ];
@@ -215,6 +216,11 @@ export function SettingsDrawer({ onClose }: Props) {
                 </div>
               </div>
               <div className="field">
+              <label>Modèle « mission » (tâches longues)</label>
+              <input className="input" list="hermes-models" value={settings.hermes.missionModel} placeholder="(même modèle)" onChange={(e) => update({ hermes: { missionModel: e.target.value } })} />
+              <span className="hint">Utilisé quand le mode Mission est activé dans la barre de commande. Laissez vide pour garder le modèle principal.</span>
+            </div>
+            <div className="field">
                 <label>Instructions EveFlow (superposées au prompt Hermes)</label>
                 <textarea className="textarea" value={settings.hermes.instructions} onChange={(e) => update({ hermes: { instructions: e.target.value } })} />
               </div>
@@ -471,6 +477,14 @@ export function SettingsDrawer({ onClose }: Props) {
   -d '{"role":"assistant","text":"Rapport terminé","source":"telegram"}'`}</pre>
               <span className="hint">Formats acceptés : {'{role,text}'}, {'{event:"run.completed",input,output}'}, {'{event:"job.completed",job:{name},output,status}'}, {'{type:"message",payload:{text}}'}.</span>
             </div>
+            <div className="field">
+              <label>Serveur MCP pour Hermes (outils du PC : écran, applications, volume, presse-papiers, voix)</label>
+              <pre className="input" style={{ whiteSpace: 'pre-wrap', fontSize: 11.5, userSelect: 'text' }}>{`# ~/.hermes/config.yaml côté Hermes
+mcp_servers:
+  eveflow:
+    url: "http://<ip-de-ce-pc>:${settings.webhook.port}/mcp"${settings.webhook.secret ? '\n    headers:\n      Authorization: "Bearer <secret>"' : ''}`}</pre>
+              <span className="hint">Même port et même secret que le webhook. Sans secret, EveFlow n’écoute qu’en local (127.0.0.1) : définissez un secret pour un Hermes distant.</span>
+            </div>
             <div className="row">
               <button className="btn primary small" onClick={() => void applyWebhook()} disabled={!bridge()}>Appliquer et redémarrer</button>
               {hermesWebhook && <span className={`status-pill ${hermesWebhook.listening ? 'online' : 'offline'}`}>{hermesWebhook.listening ? `port ${hermesWebhook.port}` : hermesWebhook.error ?? 'inactif'}</span>}
@@ -478,6 +492,35 @@ export function SettingsDrawer({ onClose }: Props) {
           </div>
         )}
 
+        {section === 'notifications' && (
+          <div className="card">
+            <Toggle on={settings.notifications.quietEnabled} onChange={(v) => update({ notifications: { quietEnabled: v } })} label="Heures calmes" hint="Les messages poussés (crons, Telegram) s’affichent sans être lus à voix haute ni faire clignoter le noyau ; le HUD passe en mode nuit." />
+            <div className="grid-2">
+              <div className="field">
+                <label>Début</label>
+                <input className="input" type="time" value={settings.notifications.quietStart} onChange={(e) => update({ notifications: { quietStart: e.target.value } })} />
+              </div>
+              <div className="field">
+                <label>Fin</label>
+                <input className="input" type="time" value={settings.notifications.quietEnd} onChange={(e) => update({ notifications: { quietEnd: e.target.value } })} />
+              </div>
+            </div>
+            <Toggle on={settings.notifications.nightTheme} onChange={(v) => update({ notifications: { nightTheme: v } })} label="Thème nuit pendant les heures calmes" />
+            <div className="field" style={{ marginTop: 10 }}>
+              <label>Mots prioritaires (lus même en heures calmes)</label>
+              <input className="input" value={settings.notifications.priorityKeywords} onChange={(e) => update({ notifications: { priorityKeywords: e.target.value } })} placeholder="urgent, alerte, panne" />
+              <span className="hint">Séparés par des virgules ; comparés au texte et au nom du cron. Les échecs de crons sont toujours prioritaires.</span>
+            </div>
+            <Toggle on={settings.notifications.summarizeIncoming} onChange={(v) => update({ notifications: { summarizeIncoming: v } })} label="Résumé vocal des messages entrants" hint="Seules les premières phrases sont lues ; le message complet reste dans le fil." />
+            {settings.notifications.summarizeIncoming && (
+              <div className="field">
+                <label>Phrases lues : {settings.notifications.summarySentences}</label>
+                <input className="range" type="range" min={1} max={5} step={1} value={settings.notifications.summarySentences} onChange={(e) => update({ notifications: { summarySentences: Number(e.target.value) } })} />
+              </div>
+            )}
+          </div>
+        )}
+
         {section === 'general' && (
           <div className="card">
             <div className="grid-2">

src/lib/quietHours.ts

@@ -0,0 +1,43 @@
+/** Quiet-hours and spoken-summary helpers (pure, unit tested). */
+
+function minutesOf(hhmm: string): number | null {
+  const m = /^(\d{1,2}):(\d{2})$/.exec(hhmm.trim());
+  if (!m) return null;
+  const h = Number(m[1]);
+  const min = Number(m[2]);
+  if (h > 23 || min > 59) return null;
+  return h * 60 + min;
+}
+
+/** True when `now` falls inside [start, end), with ranges crossing midnight ("22:30" → "07:30"). */
+export function isQuietTime(start: string, end: string, now: Date = new Date()): boolean {
+  const s = minutesOf(start);
+  const e = minutesOf(end);
+  if (s === null || e === null || s === e) return false;
+  const cur = now.getHours() * 60 + now.getMinutes();
+  return s < e ? cur >= s && cur < e : cur >= s || cur < e;
+}
+
+/** True when the text or job name contains one of the comma-separated priority words. */
+export function isPriority(text: string, keywords: string, jobName = ''): boolean {
+  const words = keywords
+    .split(/[,;\n]/)
+    .map((w) => w.trim().toLowerCase())
+    .filter(Boolean);
+  if (!words.length) return false;
+  const hay = `${jobName} ${text}`.toLowerCase();
+  return words.some((w) => hay.includes(w));
+}
+
+/** First `count` sentences of a text, for a short spoken summary of a long push. */
+export function summarize(text: string, count: number): string {
+  const clean = text
+    .replace(/```[\s\S]*?```/g, ' ')
+    .replace(/[#*_>`|]/g, '')
+    .replace(/\s+/g, ' ')
+    .trim();
+  if (!clean) return '';
+  const sentences = clean.match(/[^.!?…]+[.!?…]+["»)]?\s*|[^.!?…]+$/g) ?? [clean];
+  const picked = sentences.slice(0, Math.max(1, count)).join('').trim();
+  return picked.length < clean.length ? picked : clean;
+}

src/services/conversation.ts

@@ -9,7 +9,8 @@ import { previewText } from '../lib/text';
 import { useChat, type PendingRequest } from '../state/chat';
 import { useHermes } from '../state/hermes';
 import { useSettings } from '../state/settings';
-import { executeLocalTool, LOCAL_TOOL_DEFINITIONS } from './hermes/localTools';
+import { executeLocalTool, LOCAL_TOOL_DEFINITIONS, type LocalToolContext } from './hermes/localTools';
+import { isPriority, summarize } from '../lib/quietHours';
 import type { HermesStreamEvent, SendHandle } from './hermes/types';
 import { speech } from './voice/speech';
 import { bridge } from '../lib/bridge';
@@ -48,7 +49,7 @@ export function pingCore(): void {
   useChat.getState().ping();
 }
 
-function localToolContext() {
+export function localToolContext(): LocalToolContext {
   const chat = useChat.getState();
   const settings = useSettings.getState().settings;
   return {
@@ -60,13 +61,20 @@ function localToolContext() {
       setTimeout(() => useChat.getState().setHudOverride(null), 6000);
     },
     speak: (text: string) => speech.say(text),
+    showMessage: (text: string, title?: string) => {
+      if (!text.trim()) return;
+      useChat.getState().addMessage({ role: 'assistant', content: text, source: 'hermes', jobName: title, status: 'done' });
+    },
     getStatus: () => ({
       transport: useHermes.getState().transport,
       link: useHermes.getState().link,
       assistant: settings.assistantName,
       messages: chat.messages.length,
       speaking: speech.isSpeaking(),
-      handsFree: settings.voice.handsFree
+      handsFree: settings.voice.handsFree,
+      quietHours: chat.quiet,
+      missionMode: chat.missionMode,
+      wakeMode: settings.voice.wakeMode
     }),
     getHistory: (n: number) => chat.messages.slice(-n).map((m) => ({ role: m.role, content: m.content })),
     notify: (title: string, body: string) => {
@@ -231,7 +239,9 @@ export async function sendMessage(text: string, images: string[] = [], source =
   const timing = { firstToken: null as number | null, startedAt };
   const runIdRef = { id: null as string | null };
 
-  const client = hermes.client();
+  const mission = chat.missionMode && settings.hermes.missionModel.trim();
+  const client = hermes.client(mission ? settings.hermes.missionModel : undefined);
+  if (mission) Log.info('hermes', `mission mode → model ${settings.hermes.missionModel}`);
   const handle = client.send(
     {
       text: trimmed || 'Analyse cette image.',
@@ -363,11 +373,17 @@ export function handlePush(event: HermesPushEvent): void {
     chat.pushActivity({ kind: 'job', name: event.jobName || 'cron', status: event.status?.includes('fail') ? 'error' : 'done', detail: previewText(event.text, 160) });
     void useHermes.getState().refreshJobs();
   }
-  if (event.role !== 'user' && settings.speech.speakIncoming) {
-    speech.say(event.jobName ? `Résultat de ${event.jobName}. ${event.text}` : event.text);
+  const n = settings.notifications;
+  const priority = isPriority(event.text, n.priorityKeywords, event.jobName) || !!event.status?.includes('fail');
+  const silenced = chat.quiet && !priority;
+  if (document.hidden || silenced) chat.incUnread();
+  if (event.role !== 'user' && settings.speech.speakIncoming && !silenced) {
+    const body = n.summarizeIncoming ? summarize(event.text, n.summarySentences) : event.text;
+    speech.say(event.jobName ? `Résultat de ${event.jobName}. ${body}` : body);
   }
+  if (silenced) Log.info('webhook', 'quiet hours: push shown silently');
   chat.setHud(event.status?.includes('fail') ? 'alert' : 'success');
-  pingCore();
+  if (!silenced) pingCore();
   setTimeout(() => {
     const s = useChat.getState();
     if (s.hud === 'success' || s.hud === 'alert') s.setHud(speech.isSpeaking() ? 'speaking' : 'idle');

src/services/hermes/localTools.ts

@@ -3,16 +3,35 @@
  * With the runs/sessions transports Hermes uses its own server-side toolsets instead.
  */
 import { bridge } from '../../lib/bridge';
+import type { SystemAction } from '../../../shared/bridge';
 
 export interface LocalToolContext {
   setEmotion: (emotion: string) => void;
+  showMessage?: (text: string, title?: string) => void;
   speak: (text: string) => void;
   getStatus: () => Record<string, unknown>;
   getHistory: (n: number) => Array<{ role: string; content: string }>;
   notify: (title: string, body: string) => void;
 }
 
+const fn = (name: string, description: string, properties: Record<string, unknown> = {}, required: string[] = []) => ({
+  type: 'function',
+  function: { name, description, parameters: { type: 'object', properties, required } }
+});
+
+/** Tools executed on the user's PC through the Electron main process (allow-listed). */
+export const SYSTEM_TOOL_DEFINITIONS = [
+  fn('lock_session', "Verrouille la session de l'utilisateur."),
+  fn('open_app', "Lance une application du PC de l'utilisateur (bloc-notes, calculatrice, chrome, spotify, vscode, terminal, explorateur…).", { name: { type: 'string' } }, ['name']),
+  fn('open_url', "Ouvre une URL http(s) dans le navigateur de l'utilisateur.", { url: { type: 'string' } }, ['url']),
+  fn('media_key', 'Touche média : volume-up, volume-down, mute, play-pause, next, previous.', { key: { type: 'string', enum: ['volume-up', 'volume-down', 'mute', 'play-pause', 'next', 'previous'] } }, ['key']),
+  fn('clipboard_get', 'Lit le texte du presse-papiers.'),
+  fn('clipboard_set', 'Place un texte dans le presse-papiers.', { text: { type: 'string' } }, ['text']),
+  fn('find_files', "Cherche des fichiers par nom dans Documents, Bureau, Téléchargements et Images (25 max).", { query: { type: 'string' } }, ['query'])
+];
+
 export const LOCAL_TOOL_DEFINITIONS = [
+  ...SYSTEM_TOOL_DEFINITIONS,
   {
     type: 'function',
     function: {
@@ -95,6 +114,29 @@ export async function executeLocalTool(name: string, rawArgs: string, ctx: Local
       case 'notify_user':
         ctx.notify(String(args.title ?? 'EveFlow'), String(args.body ?? ''));
         return JSON.stringify({ ok: true });
+      case 'show_message':
+        ctx.showMessage?.(String(args.text ?? ''), typeof args.title === 'string' ? args.title : undefined);
+        return JSON.stringify({ ok: true });
+      case 'lock_session':
+      case 'open_app':
+      case 'open_url':
+      case 'media_key':
+      case 'clipboard_get':
+      case 'clipboard_set':
+      case 'find_files': {
+        const api = bridge();
+        if (!api) return JSON.stringify({ error: 'system actions unavailable outside Electron' });
+        const action: SystemAction =
+          name === 'lock_session' ? { type: 'lock' }
+          : name === 'open_app' ? { type: 'open-app', name: String(args.name ?? '') }
+          : name === 'open_url' ? { type: 'open-url', url: String(args.url ?? '') }
+          : name === 'media_key' ? { type: 'media', key: String(args.key ?? '') as 'mute' }
+          : name === 'clipboard_get' ? { type: 'clipboard-read' }
+          : name === 'clipboard_set' ? { type: 'clipboard-write', text: String(args.text ?? '') }
+          : { type: 'find-files', query: String(args.query ?? '') };
+        const result = await api.system.action(action);
+        return JSON.stringify(result.ok ? { ok: true, message: result.message, data: result.data } : { error: result.message ?? 'failed' });
+      }
       case 'write_shared_file': {
         const api = bridge();
         if (!api) return JSON.stringify({ error: 'file system unavailable outside Electron' });

src/services/hermes/types.ts

@@ -10,6 +10,8 @@ export interface HermesConfig {
   reasoningEffort: '' | 'low' | 'medium' | 'high';
   /** Extra instructions layered on top of the Hermes system prompt. */
   instructions: string;
+  /** Model used in "mission" mode (long tasks); empty = same as `model`. */
+  missionModel: string;
   /** Expose EveFlow client tools in chat-completions mode. */
   localTools: boolean;
 }

src/services/mcpBridge.ts

@@ -0,0 +1,42 @@
+/**
+ * Answers tool calls that Hermes sends through the local MCP endpoint and that need the renderer
+ * (voice, notifications, HUD, chat). System tools are executed in the main process directly.
+ */
+import type { McpToolRequest } from '../../shared/ipc';
+import { bridge } from '../lib/bridge';
+import { Log } from '../lib/log';
+import { useChat } from '../state/chat';
+import { executeLocalTool, type LocalToolContext } from './hermes/localTools';
+
+let unsubscribe: (() => void) | null = null;
+
+export function initMcpBridge(context: () => LocalToolContext): void {
+  const api = bridge();
+  if (!api || unsubscribe) return;
+  unsubscribe = api.hermes.onToolRequest((req: McpToolRequest) => {
+    void handle(req, context)
+      .then((result) => api.hermes.toolResponse({ id: req.id, ok: true, result }))
+      .catch((err: Error) => api.hermes.toolResponse({ id: req.id, ok: false, error: err.message }));
+  });
+}
+
+async function handle(req: McpToolRequest, context: () => LocalToolContext): Promise<unknown> {
+  Log.info('mcp', `tool ${req.name}`);
+  const chat = useChat.getState();
+  if (req.name === 'show_message') {
+    const text = String(req.args.text ?? '');
+    if (!text.trim()) throw new Error('texte vide');
+    chat.addMessage({ role: 'assistant', content: text, source: 'mcp', jobName: typeof req.args.title === 'string' ? req.args.title : undefined, status: 'done' });
+    chat.pushActivity({ kind: 'system', name: 'hermes → eveflow', status: 'done', detail: text.slice(0, 160) });
+    return { ok: true };
+  }
+  const raw = await executeLocalTool(req.name, JSON.stringify(req.args ?? {}), context());
+  try {
+    const parsed = JSON.parse(raw) as { error?: string };
+    if (parsed && typeof parsed === 'object' && parsed.error) throw new Error(parsed.error);
+    return parsed;
+  } catch (err) {
+    if ((err as Error).message && !(err instanceof SyntaxError)) throw err;
+    return raw;
+  }
+}

src/services/voice/voiceController.ts

@@ -242,6 +242,8 @@ class VoiceController {
     }
 
     const sensitivity = Math.min(5, Math.max(1, Math.round(settings.sensitivity))) as 1 | 2 | 3 | 4 | 5;
+    // Barge-in: while the assistant talks, demand a clearly louder signal so the speaker echo cannot trigger.
+    const barging = auto && settings.bargeIn && speech.isSpeaking();
     try {
       await audioBus.resume();
       await this.capture.start({
@@ -249,8 +251,8 @@ class VoiceController {
         mode: settings.captureMode,
         vad: {
           silenceMs: settings.silenceMs,
-          speechRatio: SENSITIVITY_RATIO[sensitivity],
-          minRms: SENSITIVITY_MIN_RMS[sensitivity],
+          speechRatio: barging ? Math.min(0.9, SENSITIVITY_RATIO[sensitivity] + 0.15) : SENSITIVITY_RATIO[sensitivity],
+          minRms: barging ? SENSITIVITY_MIN_RMS[sensitivity] * 2.5 : SENSITIVITY_MIN_RMS[sensitivity],
           noSpeechTimeoutMs: useVoice.getState().handsFree ? Number.POSITIVE_INFINITY : 9_000
         },
         callbacks: {
@@ -259,6 +261,8 @@ class VoiceController {
             if (q !== useVoice.getState().inputLevel) useVoice.getState().setInputLevel(q);
           },
           onSpeechStart: () => {
+            // The user started talking over the assistant: cut the voice (barge-in).
+            if (speech.isSpeaking()) speech.stop();
             useVoice.getState().setPhase('speech');
             useChat.getState().ping();
           },

src/state/chat.ts

@@ -57,6 +57,16 @@ interface ChatStore {
   pingCount: number;
   /** Time to first token of the current reply, in ms. */
   latencyMs: number | null;
+  /** Pushes received while the window was hidden / compact, cleared when the user looks. */
+  unread: number;
+  /** Mission mode routes the next messages to the "mission" model (long tasks). */
+  missionMode: boolean;
+  /** True while quiet hours apply (computed by App). */
+  quiet: boolean;
+  incUnread: () => void;
+  markRead: () => void;
+  setMissionMode: (on: boolean) => void;
+  setQuiet: (quiet: boolean) => void;
 
   addMessage: (message: Omit<ChatMessage, 'id' | 'timestamp'> & Partial<Pick<ChatMessage, 'id' | 'timestamp'>>) => string;
   updateMessage: (id: string, patch: Partial<ChatMessage> | ((m: ChatMessage) => Partial<ChatMessage>)) => void;
@@ -91,6 +101,13 @@ export const useChat = create<ChatStore>((set, get) => ({
   draft: '',
   pingCount: 0,
   latencyMs: null,
+  unread: 0,
+  missionMode: false,
+  quiet: false,
+  incUnread: () => set((s) => ({ unread: Math.min(99, s.unread + 1) })),
+  markRead: () => set((s) => (s.unread ? { unread: 0 } : {})),
+  setMissionMode: (missionMode) => set({ missionMode }),
+  setQuiet: (quiet) => set((s) => (s.quiet === quiet ? {} : { quiet })),
 
   addMessage: (message) => {
     const id = message.id ?? uid('msg');

src/state/hermes.ts

@@ -43,7 +43,7 @@ interface HermesStore {
   webhook: WebhookStatus | null;
   busy: boolean;
 
-  client: () => HermesClient;
+  client: (modelOverride?: string) => HermesClient;
   connect: () => Promise<void>;
   refreshJobs: () => Promise<void>;
   refreshSessions: () => Promise<void>;
@@ -93,10 +93,10 @@ export const useHermes = create<HermesStore>((set, get) => ({
   webhook: null,
   busy: false,
 
-  client: () => {
+  client: (modelOverride) => {
     const config = useSettings.getState().settings.hermes;
     // Without an explicit model, use the alias advertised by /v1/models (Hermes rejects unknown names).
-    const model = config.model.trim() || get().models[0]?.id || '';
+    const model = (modelOverride ?? '').trim() || config.model.trim() || get().models[0]?.id || '';
     return new HermesClient({ ...config, model });
   },
 

src/state/settings.ts

@@ -39,6 +39,20 @@ export interface WebhookSettings {
   secret: string;
 }
 
+export interface NotificationSettings {
+  /** Quiet hours: no spoken pushes, no chime, dimmed HUD (24 h "HH:MM"). */
+  quietEnabled: boolean;
+  quietStart: string;
+  quietEnd: string;
+  /** Pushes whose text or job name contains one of these words are spoken even during quiet hours. */
+  priorityKeywords: string;
+  /** Speak only the first sentences of incoming pushes (cron reports can be long). */
+  summarizeIncoming: boolean;
+  summarySentences: number;
+  /** Dim the HUD (night theme) during quiet hours. */
+  nightTheme: boolean;
+}
+
 export interface Settings {
   version: 2;
   assistantName: string;
@@ -49,6 +63,7 @@ export interface Settings {
   voice: VoiceSettings;
   speech: SpeechSettings;
   webhook: WebhookSettings;
+  notifications: NotificationSettings;
   ui: {
     showTelemetry: boolean;
     showReasoning: boolean;
@@ -73,7 +88,8 @@ export const DEFAULT_SETTINGS: Settings = {
     reasoningEffort: '',
     instructions:
       "Tu es l'interface vocale EveFlow (style JARVIS). Réponds en français, de façon concise et orale quand la question est simple; utilise le Markdown uniquement pour le contenu structuré (code, listes, tableaux). Les images doivent être des URL http(s) ou des fichiers du dossier partagé.",
-    localTools: true
+    localTools: true,
+    missionModel: ''
   },
   voice: {
     provider: 'openai-compatible',
@@ -113,6 +129,7 @@ export const DEFAULT_SETTINGS: Settings = {
     speakIncoming: true
   },
   webhook: { enabled: true, port: 7842, secret: '' },
+  notifications: { quietEnabled: false, quietStart: '22:30', quietEnd: '07:30', priorityKeywords: 'urgent, alerte, alarme, panne', summarizeIncoming: true, summarySentences: 2, nightTheme: true },
   ui: { showTelemetry: true, showReasoning: false, reduceMotion: false, compactOpacity: 0.92 },
   hermesSessionId: ''
 };

src/styles/compact.css

@@ -67,3 +67,54 @@
   font-size: 13px;
   padding: 8px 11px;
 }
+
+/* Glanceable strip: state, unread badge, last sentence. */
+.compact-glance {
+  display: grid;
+  grid-template-columns: auto 1fr auto;
+  align-items: center;
+  gap: 8px;
+  padding: 4px 12px 8px;
+  font-family: var(--font-mono);
+  font-size: 10.5px;
+  letter-spacing: 0.12em;
+  text-transform: uppercase;
+  color: var(--ink-2);
+}
+.compact-glance .state {
+  color: var(--accent);
+}
+.compact-glance .state.alert {
+  color: var(--danger);
+}
+.compact-glance .last {
+  font-family: var(--font-body);
+  font-size: 12.5px;
+  letter-spacing: 0;
+  text-transform: none;
+  color: var(--ink-1);
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+.compact-glance .badges {
+  display: flex;
+  gap: 6px;
+  align-items: center;
+}
+.compact-glance .unread {
+  min-width: 18px;
+  height: 18px;
+  padding: 0 5px;
+  border-radius: 9px;
+  background: var(--accent);
+  color: #03101c;
+  font-weight: 700;
+  font-size: 11px;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+}
+.compact-glance .mission {
+  color: var(--warn, #f5c451);
+}

src/styles/tokens.css

@@ -159,3 +159,15 @@ textarea {
 .kv dd {
   user-select: text;
 }
+
+/* Quiet hours: dimmer HUD, softer glow. */
+:root[data-night] {
+  --accent-glow: rgba(var(--accent-rgb), 0.18);
+}
+:root[data-night] .hud-root,
+:root[data-night] .compact-root {
+  filter: brightness(0.72) saturate(0.85);
+}
+:root[data-night] .core-stage canvas {
+  opacity: 0.8;
+}