nothumanallowed 15.1.62 → 15.1.64

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nothumanallowed",
-  "version": "15.1.62",
+  "version": "15.1.64",
   "description": "NotHumanAllowed — 38 AI agents, 80 tools, Studio (visual agentic workflows). Email, calendar, browser automation, screen capture, canvas, cron/heartbeat, Alexandria E2E messaging, GitHub, Notion, Slack, voice chat, free AI (Liara), 28 languages. Zero-dependency CLI.",
   "type": "module",
   "bin": {

package/src/constants.mjs

@@ -5,7 +5,7 @@ import { fileURLToPath } from 'url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
-export const VERSION = '15.1.62';
+export const VERSION = '15.1.64';
 export const BASE_URL = 'https://nothumanallowed.com/cli';
 export const API_BASE = 'https://nothumanallowed.com/api/v1';
 

package/src/server/routes/chat.mjs

@@ -17,7 +17,7 @@ import {
 import { callLLMStream, callLLM, callLLMVision, parseAgentFile } from '../../services/llm.mjs';
 import { buildMemoryContext } from '../../services/memory.mjs';
 import { parseActions, executeTool, buildSystemPrompt, stripOrphanFences } from '../../services/tool-executor.mjs';
-import { detectLanguage } from '../../services/message-responder.mjs';
+import { detectLanguage, tryDirectActionAll } from '../../services/message-responder.mjs';
 
 // Migrate on import (once)
 migrateOldHistory();
@@ -267,6 +267,32 @@ export function register(router) {
     }, 3000);
 
     try {
+      // ── Deterministic direct-action dispatcher (LLM-NLU + server execute) ──
+      // Same architecture used by Telegram/Discord. Before invoking the chat
+      // LLM, classify the message: if it maps to a state-changing tool
+      // (calendar/email/task/file/drive/slack/notion/github/...), execute it
+      // deterministically server-side and stream the result. No more "the
+      // model said done but didn't call the tool".
+      const direct = await tryDirectActionAll(msg, config, {
+        auditKey: `chat:${body.conversationId || 'anon'}`,
+      });
+      if (direct) {
+        if (heartbeatInterval) { clearInterval(heartbeatInterval); heartbeatInterval = null; }
+        sse('tool', { action: direct.action, status: 'done', result: (direct.message || '').slice(0, 240) });
+        sse('token', { content: direct.message });
+        // Persist to conversation
+        if (body.conversationId) {
+          try {
+            const conv = loadConversation(body.conversationId);
+            if (conv) addMessages(conv, msg, direct.message);
+          } catch {}
+        }
+        sse('done', { content: direct.message });
+        res.write('data: [DONE]\n\n');
+        res.end();
+        return;
+      }
+
       let fullResponse = '';
       fullResponse = await callLLMStream(config, enrichedPrompt, userMessage, (chunk) => {
         clearInterval(heartbeatInterval);

package/src/services/message-responder.mjs

@@ -9,7 +9,7 @@
  */
 
 import { callAgent, callLLM } from './llm.mjs';
-import { buildSystemPrompt, parseActions, executeTool, TOOL_DEFINITIONS, LIARA_TOOL_DEFINITIONS } from './tool-executor.mjs';
+import { buildSystemPrompt, parseActions, executeTool, TOOL_DEFINITIONS, LIARA_TOOL_DEFINITIONS, DESTRUCTIVE_ACTIONS } from './tool-executor.mjs';
 import https from 'https';
 import http from 'http';
 import { URL } from 'url';
@@ -829,9 +829,63 @@ class TelegramResponder {
     // Track this user for broadcast notifications (update alerts, etc.)
     touchTelegramUser(chatId, message.from?.username, message.from?.first_name);
 
-    let rawText = message.text || '';
+    let rawText = message.text || message.caption || '';
     let isVoice = false;
 
+    // ── Image / photo handler (vision via Liara or fallback provider) ──────
+    // Telegram sends `message.photo` as an array of size variants — we pick
+    // the largest. For documents (e.g. screenshots sent as files), we accept
+    // any mime starting with image/.
+    const photo = Array.isArray(message.photo) && message.photo.length
+      ? message.photo[message.photo.length - 1]
+      : null;
+    const isImageDoc = message.document && /^image\//.test(message.document.mime_type || '');
+    if (photo || isImageDoc) {
+      try {
+        await this._telegramCall('sendChatAction', { chat_id: chatId, action: 'typing' });
+        const fileId = photo ? photo.file_id : message.document.file_id;
+        const fileInfo = await this._telegramCall('getFile', { file_id: fileId });
+        const filePath = fileInfo?.result?.file_path;
+        if (!filePath) throw new Error('Telegram file_path missing');
+        const fileUrl = `https://api.telegram.org/file/bot${this.token}/${filePath}`;
+        const fileRes = await fetch(fileUrl);
+        if (!fileRes.ok) throw new Error(`Telegram file fetch ${fileRes.status}`);
+        const buf = Buffer.from(await fileRes.arrayBuffer());
+        const base64 = buf.toString('base64');
+        // Infer mediaType from file_path extension.
+        const ext = (filePath.split('.').pop() || 'jpg').toLowerCase();
+        const mediaType = ext === 'png' ? 'image/png'
+                        : ext === 'gif' ? 'image/gif'
+                        : ext === 'webp' ? 'image/webp'
+                        : 'image/jpeg';
+        const userPrompt = rawText.trim()
+          || 'Describe this image in detail. If it contains text, transcribe it exactly. Reply in Italian.';
+        const langInstruction = detectLanguage(userPrompt) || (rawText ? null : null);
+        const sysPrompt = `You are a helpful visual assistant. ${langInstruction === 'English' ? 'Reply in English.' : 'Rispondi in italiano.'} Be specific and accurate. If asked to extract text, transcribe it verbatim. If asked to identify objects, list them clearly.`;
+        const { callLLMVision } = await import('./llm.mjs');
+        const description = await callLLMVision(this.config, sysPrompt, userPrompt, { base64, mediaType });
+        const truncated = description.length > 4000 ? description.slice(0, 3950) + '\n\n... [truncated]' : description;
+        // Audit
+        this._recordAudit(chatId, {
+          tool: 'vision_describe',
+          success: true,
+          summary: `Image (${Math.round(buf.length / 1024)} KB) — "${(userPrompt).slice(0, 60)}"`,
+        });
+        const personaName = this.config.responder?.telegram?.botName || this.config.responder?.botName || '';
+        const personaMode = this.config.responder?.telegram?.personaMode || (personaName ? 'persona' : 'agent');
+        const prefix = personaMode === 'persona-only' && personaName ? ''
+                     : personaName ? `[${personaName}]\n\n`
+                     : `[HERALD]\n\n`;
+        await this._telegramCall('sendMessage', { chat_id: chatId, text: prefix + truncated });
+        this.log(`[Telegram] Image vision response to ${fromUser} (${buf.length} bytes, ${description.length} chars)`);
+      } catch (err) {
+        this.log(`[Telegram] Vision failed: ${err.message}`);
+        await this._telegramCall('sendMessage', { chat_id: chatId,
+          text: `Non riesco ad analizzare l'immagine: ${err.message}` }).catch(() => {});
+      }
+      return;
+    }
+
     // Handle voice notes — transcribe with Whisper (Groq or OpenAI)
     if (message.voice || message.audio) {
       const fileId = (message.voice || message.audio).file_id;
@@ -1047,13 +1101,17 @@ class TelegramResponder {
         this._lastDirectAuditChatId = chatId;
         // Run the per-domain direct-action dispatcher. First match wins; falls
         // through to LLM if no handler claims the message.
+        // Fast-path specialised handlers (regex-driven, lower latency for the
+        // common cases), then the universal dispatcher that covers ALL 50+
+        // mutation tools via a single LLM-NLU+deterministic-execute pass.
         const directFresh =
           await this._tryDirectFreshCalendarAction(cleanText, this.config) ||
           await this._tryDirectFreshEmailAction(cleanText, this.config) ||
           await this._tryDirectFreshTaskAction(cleanText, this.config) ||
           await this._tryDirectFreshNoteAction(cleanText, this.config) ||
           await this._tryDirectFreshReminderAction(cleanText, this.config) ||
-          await this._tryDirectFreshSlackAction(cleanText, this.config);
+          await this._tryDirectFreshSlackAction(cleanText, this.config) ||
+          await this._tryDirectFreshUniversalAction(cleanText, this.config);
         if (directFresh) {
           this.log(`[Telegram] ${fromUser}: direct-fresh ${directFresh.action} → ${directFresh.success ? 'OK' : 'FAIL'}`);
           const personaName = this.config.responder?.telegram?.botName || this.config.responder?.botName || '';
@@ -1663,6 +1721,181 @@ class TelegramResponder {
     try { return this._extractJsonObject(await callLLM(config, sys, userMessage, { temperature: 0, maxTokens: 300 })); } catch { return null; }
   }
 
+  // ════════════════════════════════════════════════════════════════════════
+  // UNIVERSAL DIRECT-ACTION DISPATCHER
+  // ════════════════════════════════════════════════════════════════════════
+  // Covers ALL 22 mutation tools in `DESTRUCTIVE_ACTIONS` (gmail, imap,
+  // calendar, contacts, tasks, slack, github, file, drive, notify).
+  // The LLM is used ONLY to (a) decide if the message maps to a tool and
+  // (b) extract the params as JSON. Tool execution is then deterministic
+  // server-side. No tool block is parsed from natural language by the
+  // model — the model can never "say done" without us actually doing it.
+  async _tryDirectFreshUniversalAction(userMessage, config) {
+    if (!userMessage || typeof userMessage !== 'string' || userMessage.length < 3) return null;
+
+    const todayIso = new Date().toISOString().slice(0, 10);
+    const sys =
+      `You are a tool-routing classifier. Given a user message in any language, decide whether it ` +
+      `requests a state-changing action that maps to ONE of these tools, and extract the params.\n\n` +
+      `ALLOWED TOOLS (you MUST pick one of these OR return null):\n` +
+      // Calendar
+      `- calendar_create(summary, start, end, description?)    — start/end ISO "YYYY-MM-DDTHH:MM:00"\n` +
+      `- calendar_move(eventId? OR title, newStart, newEnd?)   — if no eventId, title is used to find it\n` +
+      `- calendar_update(eventId? OR title, summary?, start?, end?, description?)\n` +
+      `- calendar_delete(eventId? OR title, date?)\n` +
+      // Email Gmail
+      `- gmail_send(to, subject, body)                         — primary email account\n` +
+      `- gmail_reply(messageId? OR threadHint, body)\n` +
+      `- gmail_delete(messageId? OR query)\n` +
+      `- gmail_mark_read(messageId, isRead?)\n` +
+      `- gmail_mark_starred(messageId, starred?)\n` +
+      `- gmail_archive(messageId)\n` +
+      // Email IMAP
+      `- imap_send(accountId?, to, subject, body)              — custom IMAP account\n` +
+      `- imap_reply(accountId?, messageId, body)\n` +
+      `- imap_trash(messageId)\n` +
+      `- imap_mark_read(messageId, isRead?)\n` +
+      `- imap_draft(accountId?, to, subject, body)\n` +
+      // Contacts
+      `- contact_add(name, email?, phone?, company?, address?)\n` +
+      `- contact_update(query, email?, phone?, company?, address?)\n` +
+      `- contact_delete(query)\n` +
+      // Tasks
+      `- task_add(title, priority?, due?)\n` +
+      `- task_done(title)\n` +
+      `- task_delete(title)\n` +
+      // Google Tasks
+      `- gtask_add(title, notes?, due?)\n` +
+      `- gtask_complete(title)\n` +
+      // Notes
+      `- note_add(title, content?)\n` +
+      // Reminders
+      `- notify_remind(message, when)                          — when = ISO datetime\n` +
+      `- reminder_create(message, when)\n` +
+      // Slack
+      `- slack_send(channel, text, threadTs?)                  — channel "#name"\n` +
+      `- slack_dm(user, text)                                  — user = name, id, or email\n` +
+      `- slack_react(channel, ts, emoji)\n` +
+      `- slack_mark_read(channel, ts)\n` +
+      // Notion
+      `- notion_page(title, content)                           — create a new Notion page\n` +
+      // GitHub
+      `- github_create_issue(repo, title, body?, labels?)      — repo "owner/name"\n` +
+      // File system (local to user)
+      `- file_write(path, content)\n` +
+      `- file_move(from, to)\n` +
+      `- file_delete(path)\n` +
+      `- file_mkdir(path)\n` +
+      // Google Drive
+      `- drive_upload(name, content, mimeType?)                — Google Drive\n` +
+      `- drive_update(fileId, content)\n` +
+      `- drive_delete(fileId? OR name)\n` +
+      `- drive_move(fileId, newParentFolderId? OR newName?)\n` +
+      `- drive_share(fileId, email, role?)                     — role = "reader"|"writer"|"commenter"\n` +
+      // Birthdays
+      `- birthday_add(name, date)                              — date "YYYY-MM-DD" or "MM-DD"\n` +
+      `- birthday_delete(name)\n` +
+      // Alexandria E2E
+      `- alexandria_send(channel, message)\n` +
+      // Cron
+      `- cron_create(name, schedule, command)                  — schedule = cron expression\n` +
+      `- cron_delete(name)\n\n` +
+      `Today is ${todayIso}. Relative dates: "domani" = ${this._addDaysIso(todayIso, 1).slice(0, 10)}, ` +
+      `"dopodomani" = ${this._addDaysIso(todayIso, 2).slice(0, 10)}, "lunedì/martedì/..." resolve to next occurrence.\n\n` +
+      `OUTPUT FORMAT (strict JSON, no markdown, no prose, no fences):\n` +
+      `{"tool": "tool_name" | null, "params": { ... }}\n\n` +
+      `If the message is a READ/LIST/QUERY operation (e.g. "mostra…", "che ho oggi", "leggi email", "trova"), ` +
+      `OR is conversational chat (greetings, questions, opinions) OR is ambiguous → return {"tool": null}.\n` +
+      `If a required param is genuinely missing AND not inferable → return {"tool": null}.\n` +
+      `Never invent emails, eventIds, or recipient addresses.`;
+
+    let raw;
+    try {
+      raw = await callLLM(config, sys, userMessage, { temperature: 0, maxTokens: 400 });
+    } catch (e) {
+      this.log(`[direct-universal] LLM call failed: ${e.message}`);
+      return null;
+    }
+    const parsed = this._extractJsonObject(raw);
+    if (!parsed || !parsed.tool || !DESTRUCTIVE_ACTIONS.has(parsed.tool)) return null;
+    if (!parsed.params || typeof parsed.params !== 'object') return null;
+
+    // Per-tool param normalization (matches the executor's accepted shapes).
+    const params = { ...parsed.params };
+    if (parsed.tool === 'calendar_create' && !params.summary) params.summary = params.title || params.name || params.subject;
+    if (parsed.tool === 'calendar_create' && params.start && !params.end) params.end = this._addMinutesIso(params.start, 60);
+
+    try {
+      const result = await executeTool(parsed.tool, params, config);
+      const resultStr = typeof result === 'string' ? result : JSON.stringify(result);
+      const ok = !/error|failed|not\s+found|invalid|does\s+not\s+exist|placeholder/i.test(resultStr);
+
+      if (this._lastDirectAuditChatId) {
+        this._recordAudit(this._lastDirectAuditChatId, {
+          tool: parsed.tool,
+          success: ok,
+          summary: this._summarizeParamsForAudit(parsed.tool, params),
+        });
+      }
+      const message = ok
+        ? this._formatActionResultIT(parsed.tool, params, resultStr)
+        : `Non sono riuscito a eseguire ${parsed.tool}: ${resultStr.slice(0, 240)}`;
+      return { action: parsed.tool, success: ok, message };
+    } catch (e) {
+      return { action: parsed.tool, success: false, message: `Errore durante ${parsed.tool}: ${e.message}` };
+    }
+  }
+
+  /** Natural-language Italian summary for the audit log entry. */
+  _summarizeParamsForAudit(tool, params) {
+    if (tool.startsWith('calendar_')) {
+      const t = params.summary || params.title || '';
+      const s = params.start ? this._formatDateIT(String(params.start).slice(0, 10)) + ` ${String(params.start).slice(11, 16)}` : '';
+      return `"${t}"${s ? ` · ${s}` : ''}`;
+    }
+    if (tool === 'gmail_send' || tool === 'imap_send') return `→ ${params.to || '?'} · "${(params.subject || '').slice(0, 60)}"`;
+    if (tool === 'gmail_reply' || tool === 'imap_reply') return `reply → ${params.to || params.messageId || '?'}`;
+    if (tool === 'slack_send') return `→ ${params.channel || '?'} · "${(params.text || '').slice(0, 60)}"`;
+    if (tool === 'notify_remind') return `"${params.message || ''}" @ ${params.when || '?'}`;
+    if (tool === 'github_create_issue') return `${params.repo || '?'}: "${params.title || ''}"`;
+    if (tool === 'file_write') return `${params.path || '?'} (${(params.content || '').length} chars)`;
+    if (tool === 'drive_upload') return `${params.name || '?'} (${(params.content || '').length} chars)`;
+    if (tool === 'task_done' || tool === 'task_delete' || tool === 'contact_delete') return `"${params.title || params.name || '?'}"`;
+    return JSON.stringify(params).slice(0, 80);
+  }
+
+  /** Italian-language natural response for a successful action. */
+  _formatActionResultIT(tool, params, result) {
+    switch (tool) {
+      case 'calendar_create': {
+        const t = params.summary || params.title || 'evento';
+        const when = params.start ? `${this._formatDateIT(String(params.start).slice(0, 10))} alle ${String(params.start).slice(11, 16)}` : '';
+        return `Fatto. Ho creato l'appuntamento "${t}"${when ? ` il ${when}` : ''}.`;
+      }
+      case 'calendar_move':   return `Fatto. Appuntamento spostato.`;
+      case 'calendar_update': return `Fatto. Appuntamento aggiornato.`;
+      case 'calendar_delete': return `Fatto. Appuntamento cancellato.`;
+      case 'gmail_send':
+      case 'imap_send':       return `Fatto. Email inviata a ${params.to}.`;
+      case 'gmail_reply':
+      case 'imap_reply':      return `Fatto. Risposta inviata.`;
+      case 'gmail_delete':    return `Fatto. Email eliminata.`;
+      case 'imap_trash':      return `Fatto. Email spostata nel cestino.`;
+      case 'contact_delete':  return `Fatto. Contatto "${params.name || ''}" cancellato.`;
+      case 'task_done':       return `Fatto. Task "${params.title || ''}" completato.`;
+      case 'task_delete':     return `Fatto. Task "${params.title || ''}" cancellato.`;
+      case 'task_clear':      return `Fatto. Task list pulita.`;
+      case 'notify_remind':   return `Promemoria impostato: "${params.message || ''}" per ${params.when || ''}.`;
+      case 'slack_send':      return `Fatto. Messaggio inviato a ${params.channel || ''}.`;
+      case 'github_create_issue': return `Issue creata su ${params.repo}: "${params.title}".`;
+      case 'file_write':      return `Fatto. File ${params.path} scritto (${(params.content || '').length} caratteri).`;
+      case 'drive_upload':    return `Fatto. "${params.name}" caricato su Google Drive.`;
+      case 'drive_update':    return `Fatto. File Drive aggiornato.`;
+      case 'drive_delete':    return `Fatto. File Drive eliminato.`;
+      default: return `Fatto. ${result.slice(0, 200)}`;
+    }
+  }
+
   // ── Direct fresh calendar action (no LLM) ─────────────────────────────────
   // Detects DELETE / LIST_MONTH / LIST_WEEK / LIST_DAY / LIST_TODAY /
   // LIST_TOMORROW intents from a fresh user message and runs the proper tool
@@ -2010,6 +2243,50 @@ class TelegramResponder {
   }
 }
 
+// ── Shared direct-action dispatcher (Telegram / Discord / Chat WebUI / Voice) ─
+// A reusable, instance-less handler. Internally piggybacks on a singleton
+// TelegramResponder built with a dummy config — we only use it as a host for
+// the `_tryDirectFresh*` methods. The audit log is keyed by the caller's
+// own `auditKey` (chatId for Telegram, channelId for Discord, conversationId
+// for Chat WebUI), so each platform keeps its own action history without
+// crossing wires.
+let _sharedDirectHandler = null;
+function _getDirectHandler() {
+  if (!_sharedDirectHandler) {
+    _sharedDirectHandler = new TelegramResponder(
+      { responder: { telegram: { token: '__noop__' } } },
+      () => {},
+      () => {},
+    );
+    // Ensure the in-memory store exists.
+    _sharedDirectHandler._lastContextByChatId = _sharedDirectHandler._lastContextByChatId || {};
+  }
+  return _sharedDirectHandler;
+}
+
+/**
+ * Try every direct-action handler in order (fast-path → universal). Returns
+ * `{action, success, message}` on hit, `null` if nothing claimed the message.
+ *
+ * @param {string} text       — the raw user message in any language
+ * @param {object} config     — loaded nha config (used by tools + LLM NLU)
+ * @param {object} [opts]
+ *   @param {string} [opts.auditKey]   — stable key for action audit (chatId, channelId, conversationId…)
+ *   @param {(line:string)=>void} [opts.log] — optional logger
+ */
+export async function tryDirectActionAll(text, config, opts = {}) {
+  const h = _getDirectHandler();
+  if (opts.auditKey) h._lastDirectAuditChatId = opts.auditKey;
+  if (opts.log) h.log = opts.log;
+  return await h._tryDirectFreshCalendarAction(text, config)
+      || await h._tryDirectFreshEmailAction(text, config)
+      || await h._tryDirectFreshTaskAction(text, config)
+      || await h._tryDirectFreshNoteAction(text, config)
+      || await h._tryDirectFreshReminderAction(text, config)
+      || await h._tryDirectFreshSlackAction(text, config)
+      || await h._tryDirectFreshUniversalAction(text, config);
+}
+
 // ── Discord Bot (Gateway WebSocket via raw TLS, zero dependencies) ───────────
 
 class DiscordResponder {
@@ -2333,6 +2610,21 @@ class DiscordResponder {
     this.pendingRequests++;
 
     try {
+      // Try the deterministic direct-action dispatcher BEFORE routing to an
+      // LLM agent. Same architecture used by Telegram: LLM only for NLU,
+      // tool execution always server-side, audit log per channel.
+      const directFresh = await tryDirectActionAll(cleanText, this.config, {
+        auditKey: `discord:${channelId}`,
+        log: this.log,
+      });
+      if (directFresh) {
+        await this._discordApiCall('POST', `/channels/${channelId}/messages`, {
+          content: directFresh.message,
+        });
+        this.log(`[Discord] direct-action ${directFresh.action} → ${directFresh.success ? 'OK' : 'FAIL'}`);
+        return;
+      }
+
       const agent = routeMessage(cleanText, this.autoRoute);
       this.log(`[Discord] ${fromUser} (#${channelId}): routed to ${agent.toUpperCase()}`);
 

package/src/services/tool-executor.mjs

@@ -63,30 +63,39 @@ function getTsxPath() {
 
 /** Actions that mutate external state and require user confirmation. */
 export const DESTRUCTIVE_ACTIONS = new Set([
-  'gmail_send',
-  'gmail_send_attach',
-  'gmail_reply',
-  'gmail_delete',
-  'imap_send',
-  'imap_reply',
-  'imap_bulk_send',
-  'imap_send_template',
-  'imap_trash',
-  'calendar_create',
-  'calendar_move',
-  'calendar_update',
-  'calendar_delete',
-  'contact_delete',
-  'task_done',
-  'task_delete',
-  'task_clear',
-  'notify_remind',
-  'slack_send',
-  'github_create_issue',
-  'file_write',
-  'drive_upload',
-  'drive_update',
-  'drive_delete',
+  // Gmail
+  'gmail_send', 'gmail_send_attach', 'gmail_reply', 'gmail_delete',
+  'gmail_mark_read', 'gmail_mark_starred', 'gmail_archive', 'gmail_trash',
+  // IMAP (custom email accounts)
+  'imap_send', 'imap_reply', 'imap_bulk_send', 'imap_send_template',
+  'imap_trash', 'imap_mark_read', 'imap_mark_starred', 'imap_draft',
+  // Calendar
+  'calendar_create', 'calendar_move', 'calendar_update', 'calendar_delete',
+  // Contacts
+  'contact_add', 'contact_update', 'contact_delete',
+  // Tasks (local) + Google Tasks
+  'task_add', 'task_done', 'task_delete', 'task_clear',
+  'gtask_add', 'gtask_complete', 'gtask_delete',
+  // Notes
+  'note_add',
+  // Reminders / notifications
+  'notify_remind', 'reminder_create',
+  // Slack
+  'slack_send', 'slack_dm', 'slack_react', 'slack_mark_read',
+  // Notion
+  'notion_page', 'notion_update',
+  // GitHub
+  'github_create_issue', 'github_comment',
+  // File system (local)
+  'file_write', 'file_move', 'file_delete', 'file_mkdir',
+  // Google Drive
+  'drive_upload', 'drive_update', 'drive_delete', 'drive_move', 'drive_share',
+  // Birthdays
+  'birthday_add', 'birthday_update', 'birthday_delete',
+  // Alexandria messaging
+  'alexandria_send',
+  // Cron / scheduling
+  'cron_create', 'cron_delete',
 ]);
 
 // ── Tool Definitions (for system prompt) ─────────────────────────────────────