nothumanallowed 16.0.14 → 16.0.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nothumanallowed",
-  "version": "16.0.14",
+  "version": "16.0.16",
   "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 = '16.0.14';
+export const VERSION = '16.0.16';
 export const BASE_URL = 'https://nothumanallowed.com/cli';
 export const API_BASE = 'https://nothumanallowed.com/api/v1';
 

package/src/server/routes/chat.mjs

@@ -16,7 +16,7 @@ import {
 } from '../../services/conversations.mjs';
 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 { parseActions, executeTool, executeToolAndRemember, buildSystemPrompt, stripOrphanFences } from '../../services/tool-executor.mjs';
 import { detectLanguage, tryDirectActionAll } from '../../services/message-responder.mjs';
 
 // Migrate on import (once)
@@ -487,7 +487,11 @@ export function register(router) {
         if (action === 'web_search' && wantsScreenshot) params.screenshot = true;
         sse('tool', { action, status: 'executing' });
         try {
-          const result = await executeTool(action, params, config);
+          // Use the remembering variant so list-tools auto-populate the
+          // anaphoric cache (~/.nha/list-cache.json). Same chatId/auditKey
+          // pattern as direct-action handlers.
+          const auditKey = `chat:${body.conversationId || 'anon'}`;
+          const result = await executeToolAndRemember(action, params, config, auditKey);
 
           // ── Screenshot result handling ───────────────────────────────────
           if (result && typeof result === 'object' && result.__screenshot) {

package/src/services/list-cache.mjs

@@ -0,0 +1,93 @@
+/**
+ * Last-list cache — shared between tool-executor and message-responder.
+ *
+ * Whenever a list-tool runs (gmail_list, task_list, drive_list, etc.) the
+ * structured items are stored here keyed by chatId. The anaphoric resolver
+ * in message-responder reads from here to map "cancellalo / aprilo / il
+ * primo / l'ultimo" to the correct item ID.
+ *
+ * Persisted to ~/.nha/list-cache.json so it survives daemon restarts.
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { NHA_DIR } from '../constants.mjs';
+
+const CACHE_FILE = path.join(NHA_DIR, 'list-cache.json');
+const MAX_ITEMS_PER_LIST = 50;       // cap per list to avoid prompt explosion
+
+let _inMemory = null;
+
+function _load() {
+  if (_inMemory) return _inMemory;
+  try {
+    if (fs.existsSync(CACHE_FILE)) {
+      _inMemory = JSON.parse(fs.readFileSync(CACHE_FILE, 'utf-8'));
+    } else {
+      _inMemory = {};
+    }
+  } catch { _inMemory = {}; }
+  return _inMemory;
+}
+
+function _save() {
+  try {
+    if (!fs.existsSync(NHA_DIR)) fs.mkdirSync(NHA_DIR, { recursive: true });
+    fs.writeFileSync(CACHE_FILE, JSON.stringify(_inMemory, null, 2));
+  } catch {}
+}
+
+/**
+ * Store the most recently shown items of a given kind for a given chat.
+ * @param {string} chatId   — caller identity ('chat:abc', telegramChatId, '__last_list__')
+ * @param {string} kind     — 'calendar' | 'email' | 'task' | 'contact' | 'drive' | 'note' | 'reminder' | 'gtask' | 'notion' | 'slack' | 'github' | any
+ * @param {Array<object>} items — structured items, each must have an id field
+ */
+export function rememberList(chatId, kind, items) {
+  if (!kind || !Array.isArray(items)) return;
+  const cache = _load();
+  const key = chatId || '__last_list__';
+  cache[key] = cache[key] || {};
+  const capped = items.slice(0, MAX_ITEMS_PER_LIST);
+  cache[key][`lastList_${kind}`] = capped;
+  cache[key][`lastList_${kind}_at`] = Date.now();
+  cache[key].lastListKind = kind;
+  cache[key].lastListAt = Date.now();
+  _save();
+}
+
+/**
+ * Retrieve items by kind for a chatId. Falls back to the freshest list of
+ * that kind across ALL chats if the specific one is empty.
+ */
+export function getList(chatId, kind) {
+  const cache = _load();
+  const direct = cache[chatId || '__last_list__']?.[`lastList_${kind}`];
+  if (Array.isArray(direct) && direct.length > 0) return direct;
+  // Fallback: best-most-recent across chats.
+  let best = null, bestAt = 0;
+  for (const v of Object.values(cache)) {
+    const items = v?.[`lastList_${kind}`];
+    const at = v?.[`lastList_${kind}_at`] || 0;
+    if (Array.isArray(items) && items.length > 0 && at > bestAt) {
+      best = items; bestAt = at;
+    }
+  }
+  return best || [];
+}
+
+/**
+ * What kind was last listed (any chat). Used when the user issues an
+ * anaphoric command without specifying kind.
+ */
+export function getLastListKind(chatId) {
+  const cache = _load();
+  if (chatId && cache[chatId]?.lastListKind) return cache[chatId].lastListKind;
+  let bestKind = null, bestAt = 0;
+  for (const v of Object.values(cache)) {
+    if (v?.lastListKind && (v.lastListAt || 0) > bestAt) {
+      bestKind = v.lastListKind; bestAt = v.lastListAt;
+    }
+  }
+  return bestKind;
+}

package/src/services/message-responder.mjs

@@ -1486,6 +1486,244 @@ class TelegramResponder {
   // Parse calendar_date / calendar_find tool output. The executor returns
   // a human-readable string with each event on its own line plus the
   // eventId in parentheses. We extract structured records.
+  // ── Generic LIST→REMEMBER + ANAPHORIC RESOLUTION (v16.0.16) ────────────
+  // Same pattern as the calendar fix, applied uniformly to every list-tool:
+  // email, task, contact, drive, note, reminder, gtask, notion.
+  // Why: a single regex parser can never handle every tool's ID format.
+  // The cleanest path is to call the low-level API directly and persist
+  // structured items, then resolve anaphoric references generically.
+  // Open allowlist of kinds — no hardcoded restriction. Any new tool can
+  // call _rememberItems(<any-kind-string>, items) without changing this file.
+  _propForKind(kind) { return `lastList_${kind}`; }
+
+  _rememberItems(kind, items, extra = {}) {
+    if (!kind || !Array.isArray(items)) return;
+    const chatId = this._lastDirectAuditChatId || '__last_list__';
+    const prop = this._propForKind(kind);
+    const prev = this._lastContextByChatId[chatId] || {};
+    this._lastContextByChatId[chatId] = {
+      ...prev,
+      [prop]: items,
+      [`${prop}At`]: Date.now(),
+      lastListKind: kind,
+      lastListAt: Date.now(),
+      ...extra,
+    };
+    this.log(`[direct] ${kind} LIST stored: chatId=${chatId} count=${items.length}`);
+    try { saveTelegramContext(this._lastContextByChatId); } catch {}
+  }
+
+  /**
+   * Resolve an anaphoric reference ("cancellalo", "il primo", "l'ultimo",
+   * "il numero 2") against the most recently listed items of a given kind.
+   * If kind is omitted, falls back to lastListKind (the most recently listed
+   * type — calendar after calendar_today, email after gmail_list, etc).
+   * Cross-key fallback included.
+   */
+  _resolveAnaphoric(kind, userMessage) {
+    const chatId = this._lastDirectAuditChatId;
+    // Use the shared list-cache module as source of truth — it's populated
+    // by executeToolAndRemember from every channel.
+    let items = [];
+    try {
+      const cacheFile = path.join(os.homedir(), '.nha', 'list-cache.json');
+      let cache = {};
+      if (fs.existsSync(cacheFile)) {
+        try { cache = JSON.parse(fs.readFileSync(cacheFile, 'utf-8')); } catch { cache = {}; }
+      }
+      if (!kind) {
+        // Auto-pick the freshest list across any chat.
+        const direct = chatId && cache[chatId];
+        if (direct?.lastListKind) kind = direct.lastListKind;
+        else {
+          let bestKind = null, bestAt = 0;
+          for (const v of Object.values(cache)) {
+            if (v?.lastListKind && (v.lastListAt || 0) > bestAt) { bestKind = v.lastListKind; bestAt = v.lastListAt; }
+          }
+          kind = bestKind;
+        }
+      }
+      if (!kind) return null;
+      const prop = `lastList_${kind}`;
+      items = (chatId && cache[chatId]?.[prop]) || [];
+      if (items.length === 0) {
+        let bestArr = null, bestAt = 0;
+        for (const v of Object.values(cache)) {
+          if (Array.isArray(v?.[prop]) && v[prop].length > 0 && (v[`${prop}_at`] || 0) > bestAt) {
+            bestArr = v[prop]; bestAt = v[`${prop}_at`] || 0;
+          }
+        }
+        if (bestArr) items = bestArr;
+      }
+    } catch {}
+    if (items.length === 0) return null;
+    const low = (userMessage || '').toLowerCase();
+    const ordinalMap = { primo: 0, prima: 0, secondo: 1, seconda: 1, terzo: 2, terza: 2, quarto: 3, quinto: 4, first: 0, second: 1, third: 2 };
+    for (const [word, idx] of Object.entries(ordinalMap)) {
+      if (new RegExp(`\\b${word}\\b`).test(low) && items[idx]) return { item: items[idx], kind };
+    }
+    if (/\b(ultim[oa]|last)\b/.test(low)) return { item: items[items.length - 1], kind };
+    const numMatch = low.match(/\b(?:numero|number|n\.?|#)\s*(\d+)\b/);
+    if (numMatch) {
+      const idx = parseInt(numMatch[1], 10) - 1;
+      if (items[idx]) return { item: items[idx], kind };
+    }
+    if (items.length === 1) return { item: items[0], kind };
+    return null;
+  }
+
+  /**
+   * Detect a generic anaphoric DELETE/COMPLETE/REPLY/OPEN command.
+   * Returns the matched action verb or null.
+   */
+  _detectAnaphoricAction(userMessage) {
+    const t = (userMessage || '').trim();
+    if (!t) return null;
+    const yes = /^\s*(s[ìi]\b|si\s|sì\s|ok\b|okay\b|certo\b|certamente\b|d'?accordo\b|fai|fallo|procedi|esegui|conferm[oa]|yes\b|yep\b|confirm\b|do\s*it|go\s*ahead)/i.test(t);
+    if (yes) return 'confirm';
+    if (/(cancell|elimin|rimuov|delete|remove)\w*\s*[!.?]?$/i.test(t)) return 'delete';
+    if (/(complet|don[ei]|spunt|finit|fatt)\w*\s*[!.?]?$/i.test(t)) return 'complete';
+    if (/(rispond|reply|risp\b)\w*\s*[!.?]?$/i.test(t)) return 'reply';
+    if (/(apri|open|leggi|read|mostra|view)\w*\s*[!.?]?$/i.test(t)) return 'open';
+    return null;
+  }
+
+  /**
+   * Execute an anaphoric verb (delete/complete/reply/open/confirm) against
+   * an item resolved by _resolveAnaphoric. The (verb, kind) pair maps to a
+   * concrete tool call. Unknown combinations return null (fall through to
+   * the LLM). All executions persist to the global audit log.
+   */
+  async _executeAnaphoricVerb(verb, kind, item, userText, config) {
+    const { executeTool } = await import('./tool-executor.mjs');
+    const chatId = this._lastDirectAuditChatId;
+    const auditAndReturn = (toolName, success, message, summary) => {
+      if (chatId) this._recordAudit(chatId, { tool: toolName, success, summary });
+      return { action: toolName, success, message };
+    };
+
+    // confirm = treat as the pending action (default: delete) when there's
+    // a single recently-listed item.
+    const effective = verb === 'confirm' ? 'delete' : verb;
+
+    // ── DELETE family ─────────────────────────────────────────────────────
+    if (effective === 'delete') {
+      if (kind === 'calendar' && item.eventId) {
+        try { await executeTool('calendar_delete', { eventId: item.eventId }, config); return auditAndReturn('calendar_delete', true, `Ho cancellato "${item.summary}".`, item.summary); }
+        catch (e) { return auditAndReturn('calendar_delete', false, `Errore: ${e.message}`, ''); }
+      }
+      if (kind === 'email' && (item.messageId || item.id)) {
+        try { await executeTool('gmail_delete', { messageId: item.messageId || item.id }, config); return auditAndReturn('gmail_delete', true, `Ho eliminato l'email "${item.subject || item.summary}".`, item.subject || ''); }
+        catch (e) { return auditAndReturn('gmail_delete', false, `Errore: ${e.message}`, ''); }
+      }
+      if (kind === 'task' && item.id) {
+        try { await executeTool('task_delete', { id: item.id }, config); return auditAndReturn('task_delete', true, `Ho eliminato il task "${item.description || item.summary}".`, ''); }
+        catch (e) { return auditAndReturn('task_delete', false, `Errore: ${e.message}`, ''); }
+      }
+      if (kind === 'contact' && item.id) {
+        try { await executeTool('contact_delete', { id: item.id }, config); return auditAndReturn('contact_delete', true, `Ho eliminato il contatto "${item.name || item.summary}".`, ''); }
+        catch (e) { return auditAndReturn('contact_delete', false, `Errore: ${e.message}`, ''); }
+      }
+      if (kind === 'drive' && (item.fileId || item.id)) {
+        try { await executeTool('drive_delete', { fileId: item.fileId || item.id }, config); return auditAndReturn('drive_delete', true, `Ho eliminato il file "${item.name || item.summary}".`, ''); }
+        catch (e) { return auditAndReturn('drive_delete', false, `Errore: ${e.message}`, ''); }
+      }
+      if (kind === 'note' && item.id) {
+        try { await executeTool('note_delete', { id: item.id }, config); return auditAndReturn('note_delete', true, `Ho eliminato la nota "${item.title || item.summary}".`, ''); }
+        catch (e) { return auditAndReturn('note_delete', false, `Errore: ${e.message}`, ''); }
+      }
+      if (kind === 'reminder' && item.id) {
+        try { await executeTool('reminder_cancel', { id: item.id }, config); return auditAndReturn('reminder_cancel', true, `Ho cancellato il promemoria "${item.message || item.summary}".`, ''); }
+        catch (e) { return auditAndReturn('reminder_cancel', false, `Errore: ${e.message}`, ''); }
+      }
+      if (kind === 'gtask' && (item.id || item.taskId)) {
+        try { await executeTool('gtask_delete', { id: item.id || item.taskId }, config); return auditAndReturn('gtask_delete', true, `Ho eliminato il task Google "${item.title || item.summary}".`, ''); }
+        catch (e) { return auditAndReturn('gtask_delete', false, `Errore: ${e.message}`, ''); }
+      }
+    }
+
+    // ── COMPLETE family (tasks) ──────────────────────────────────────────
+    if (effective === 'complete') {
+      if (kind === 'task' && item.id) {
+        try { await executeTool('task_done', { id: item.id }, config); return auditAndReturn('task_done', true, `Ho completato il task "${item.description || item.summary}".`, ''); }
+        catch (e) { return auditAndReturn('task_done', false, `Errore: ${e.message}`, ''); }
+      }
+      if (kind === 'gtask' && (item.id || item.taskId)) {
+        try { await executeTool('gtask_complete', { id: item.id || item.taskId }, config); return auditAndReturn('gtask_complete', true, `Ho completato il task Google "${item.title || item.summary}".`, ''); }
+        catch (e) { return auditAndReturn('gtask_complete', false, `Errore: ${e.message}`, ''); }
+      }
+    }
+
+    // ── OPEN/READ family ─────────────────────────────────────────────────
+    if (effective === 'open') {
+      if (kind === 'email' && (item.messageId || item.id)) {
+        try { const out = await executeTool('gmail_read', { messageId: item.messageId || item.id }, config); return { action: 'gmail_read', success: true, message: String(out) }; }
+        catch (e) { return { action: 'gmail_read', success: false, message: `Errore: ${e.message}` }; }
+      }
+      if (kind === 'drive' && (item.fileId || item.id)) {
+        try { const out = await executeTool('drive_read', { fileId: item.fileId || item.id }, config); return { action: 'drive_read', success: true, message: String(out) }; }
+        catch (e) { return { action: 'drive_read', success: false, message: `Errore: ${e.message}` }; }
+      }
+      if (kind === 'note' && item.id) {
+        try { const out = await executeTool('note_read', { id: item.id }, config); return { action: 'note_read', success: true, message: String(out) }; }
+        catch (e) { return { action: 'note_read', success: false, message: `Errore: ${e.message}` }; }
+      }
+    }
+
+    // ── REPLY family (email only) ────────────────────────────────────────
+    if (effective === 'reply' && kind === 'email' && (item.messageId || item.id)) {
+      // We don't know the reply body yet — return a prompt so the LLM can
+      // ask the user. Tag the message so the next turn knows context.
+      return {
+        action: 'gmail_reply_pending', success: true,
+        message: `Sto per rispondere a "${item.subject || item.from}". Scrivi il testo della risposta e procedo.`,
+      };
+    }
+
+    // Unknown verb+kind combination → fall back to the regular handlers.
+    return null;
+  }
+
+  /**
+   * Map a list-tool invocation to the (timeMin, timeMax) range that listEvents
+   * would query. Used as a fallback when the textual tool output doesn't
+   * include event IDs (calendar_month, calendar_today, etc).
+   */
+  _computeRangeForListTool(toolName, args) {
+    const now = new Date();
+    if (toolName === 'calendar_today') {
+      const from = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+      return { from, to: new Date(from.getTime() + 86400000) };
+    }
+    if (toolName === 'calendar_tomorrow') {
+      const from = new Date(now.getFullYear(), now.getMonth(), now.getDate() + 1);
+      return { from, to: new Date(from.getTime() + 86400000) };
+    }
+    if (toolName === 'calendar_week') {
+      const from = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+      return { from, to: new Date(from.getTime() + 7 * 86400000) };
+    }
+    if (toolName === 'calendar_month') {
+      let y = now.getFullYear(), m = now.getMonth();
+      if (args?.month && /^\d{4}-\d{2}$/.test(args.month)) {
+        const [yy, mm] = args.month.split('-');
+        y = parseInt(yy, 10);
+        m = parseInt(mm, 10) - 1;
+      }
+      return { from: new Date(y, m, 1), to: new Date(y, m + 1, 1) };
+    }
+    if (toolName === 'calendar_date' && args?.date && /^\d{4}-\d{2}-\d{2}$/.test(args.date)) {
+      const [yy, mm, dd] = args.date.split('-').map(n => parseInt(n, 10));
+      const from = new Date(yy, mm - 1, dd);
+      return { from, to: new Date(from.getTime() + 86400000) };
+    }
+    if (toolName === 'calendar_upcoming') {
+      const hours = parseInt(args?.hours || '48', 10);
+      return { from: now, to: new Date(now.getTime() + hours * 3600000) };
+    }
+    return null;
+  }
+
   _parseEventsFromToolOutput(toolResult) {
     const text = typeof toolResult === 'string' ? toolResult : JSON.stringify(toolResult || '');
     const lines = text.split(/\r?\n/);
@@ -2263,7 +2501,28 @@ class TelegramResponder {
       const runListAndRemember = async (toolName, args, actionKey) => {
         try {
           const out = await executeTool(toolName, args, config);
-          const events = this._parseEventsFromToolOutput(String(out));
+          // Parse from text first (cheap, works when tools include event IDs).
+          let events = this._parseEventsFromToolOutput(String(out));
+          // Fallback: tools like calendar_month don't print event IDs in their
+          // pretty-printed output, so we MUST call listEvents() directly to
+          // get structured objects with real Google Calendar event IDs.
+          // Without this, anaphoric "cancellalo" can never resolve.
+          if (events.length === 0) {
+            try {
+              const { listEvents } = await import('./google-calendar.mjs');
+              const range = this._computeRangeForListTool(toolName, args);
+              if (range) {
+                const evs = await listEvents(config, 'primary', range.from, range.to);
+                events = (evs || []).map(e => ({
+                  eventId: e.id,
+                  summary: e.summary || '(senza titolo)',
+                  time: (e.start || '').slice(11, 16),
+                  date: (e.start || '').slice(0, 10),
+                }));
+                this.log(`[direct] LIST structured fallback: ${events.length} events via listEvents(${range.from.toISOString().slice(0,10)}..${range.to.toISOString().slice(0,10)})`);
+              }
+            } catch (e) { this.log(`[direct] LIST structured fallback failed: ${e.message}`); }
+          }
           // Even without chatId, save to a global fallback bucket so the
           // anaphoric resolution can still find it.
           const persistKey = chatId || '__last_list__';
@@ -2504,6 +2763,26 @@ export async function tryDirectActionAll(text, config, opts = {}) {
   const h = _getDirectHandler();
   if (opts.auditKey) h._lastDirectAuditChatId = opts.auditKey;
   if (opts.log) h.log = opts.log;
+
+  // ── UNIVERSAL ANAPHORIC DISPATCHER (v16.0.16) ──
+  // Intercept anaphoric / yes-confirm commands BEFORE any sub-handler. Resolves
+  // the referent from the most recent list (any kind) and executes the right
+  // tool deterministically. Stops the LLM from running fake-actions.
+  const anaphor = h._detectAnaphoricAction ? h._detectAnaphoricAction(text) : null;
+  if (anaphor) {
+    const resolved = h._resolveAnaphoric ? h._resolveAnaphoric(null, text) : null;
+    if (resolved && resolved.item) {
+      try {
+        const result = await h._executeAnaphoricVerb(anaphor, resolved.kind, resolved.item, text, config);
+        if (result) return result;
+      } catch (e) {
+        h.log && h.log(`[direct] anaphoric universal dispatcher error: ${e.message}`);
+      }
+    } else {
+      h.log && h.log(`[direct] anaphoric verb=${anaphor} but no item to resolve`);
+    }
+  }
+
   return await h._tryDirectFreshCalendarAction(text, config)
       || await h._tryDirectFreshEmailAction(text, config)
       || await h._tryDirectFreshTaskAction(text, config)

package/src/services/tool-executor.mjs

@@ -1386,6 +1386,169 @@ function isPlaceholderEventId(id) {
   return false;
 }
 
+/**
+ * Wrapper around executeTool that ALSO persists structured items for
+ * any list-tool, so the anaphoric resolver in message-responder can later
+ * map "cancellalo / il primo / aprilo" to the correct item ID.
+ * Use this from chat.mjs / message-responder.mjs to get free "memory"
+ * across turns and channels.
+ */
+export async function executeToolAndRemember(action, params, config, chatId) {
+  const result = await executeTool(action, params, config);
+  try { await _maybeRememberList(action, params, result, config, chatId); } catch {}
+  return result;
+}
+
+async function _maybeRememberList(action, params, result, config, chatId) {
+  if (!action) return;
+  const { rememberList } = await import('./list-cache.mjs');
+  // ── CALENDAR list tools — call listEvents directly for structured IDs ──
+  if (['calendar_today', 'calendar_tomorrow', 'calendar_week', 'calendar_month', 'calendar_date', 'calendar_upcoming'].includes(action)) {
+    try {
+      const { listEvents } = await import('./google-calendar.mjs');
+      const now = new Date();
+      let from, to;
+      if (action === 'calendar_today') { from = new Date(now.getFullYear(), now.getMonth(), now.getDate()); to = new Date(from.getTime() + 86400000); }
+      else if (action === 'calendar_tomorrow') { from = new Date(now.getFullYear(), now.getMonth(), now.getDate() + 1); to = new Date(from.getTime() + 86400000); }
+      else if (action === 'calendar_week') { from = new Date(now.getFullYear(), now.getMonth(), now.getDate()); to = new Date(from.getTime() + 7 * 86400000); }
+      else if (action === 'calendar_month') {
+        let y = now.getFullYear(), m = now.getMonth();
+        if (params?.month && /^\d{4}-\d{2}$/.test(params.month)) { const [yy, mm] = params.month.split('-'); y = parseInt(yy, 10); m = parseInt(mm, 10) - 1; }
+        from = new Date(y, m, 1); to = new Date(y, m + 1, 1);
+      }
+      else if (action === 'calendar_date' && params?.date) { const [yy, mm, dd] = params.date.split('-').map(n => parseInt(n, 10)); from = new Date(yy, mm - 1, dd); to = new Date(from.getTime() + 86400000); }
+      else if (action === 'calendar_upcoming') { const h = parseInt(params?.hours || '48', 10); from = now; to = new Date(now.getTime() + h * 3600000); }
+      if (from && to) {
+        const evs = await listEvents(config, 'primary', from, to);
+        const items = (evs || []).map(e => ({ eventId: e.id, id: e.id, summary: e.summary || '(senza titolo)', time: (e.start || '').slice(11, 16), date: (e.start || '').slice(0, 10) }));
+        rememberList(chatId, 'calendar', items);
+      }
+    } catch {}
+    return;
+  }
+  // ── EMAIL list tools ──
+  if (['gmail_list', 'gmail_search', 'gmail_unread', 'email_search', 'email_list'].includes(action)) {
+    try {
+      const { listMessages, getMessage } = await import('./google-gmail.mjs');
+      const query = params?.query || (action === 'gmail_unread' ? 'is:unread' : 'in:inbox');
+      const refs = await listMessages(config, query, params?.maxResults || 10);
+      const items = [];
+      for (const ref of refs.slice(0, 10)) {
+        try { const m = await getMessage(config, ref.id); items.push({ messageId: m.id, id: m.id, subject: m.subject, from: m.from, date: m.date }); }
+        catch {}
+      }
+      rememberList(chatId, 'email', items);
+    } catch {}
+    return;
+  }
+  // ── TASK list (internal NHA tasks) ──
+  if (action === 'task_list') {
+    try {
+      const { getTasks } = await import('./tasks.mjs');
+      const items = (getTasks() || []).map(t => ({ id: t.id, description: t.description, priority: t.priority, due: t.due }));
+      rememberList(chatId, 'task', items);
+    } catch {}
+    return;
+  }
+  // ── GOOGLE TASKS list ──
+  if (action === 'gtask_list') {
+    try {
+      const { listGTasks } = await import('./google-tasks.mjs').catch(() => ({}));
+      if (listGTasks) {
+        const tasks = await listGTasks(config, params?.listId);
+        const items = (tasks || []).map(t => ({ id: t.id, taskId: t.id, title: t.title, due: t.due }));
+        rememberList(chatId, 'gtask', items);
+      }
+    } catch {}
+    return;
+  }
+  // ── CONTACT search ──
+  if (action === 'contact_search' || action === 'contact_list') {
+    try {
+      const { searchContacts, listContacts } = await import('./google-contacts.mjs').catch(() => ({}));
+      const fn = action === 'contact_search' ? searchContacts : listContacts;
+      if (fn) {
+        const arr = await fn(config, params?.query || '');
+        const items = (arr || []).map(c => ({ id: c.resourceName || c.id, name: c.name || c.displayName, email: c.email }));
+        rememberList(chatId, 'contact', items);
+      }
+    } catch {}
+    return;
+  }
+  // ── DRIVE list ──
+  if (action === 'drive_list' || action === 'drive_search') {
+    try {
+      const { listDriveFiles } = await import('./google-drive.mjs').catch(() => ({}));
+      if (listDriveFiles) {
+        const files = await listDriveFiles(config, params?.folderId || null, params?.query || '');
+        const items = (files || []).map(f => ({ fileId: f.id, id: f.id, name: f.name, mimeType: f.mimeType }));
+        rememberList(chatId, 'drive', items);
+      }
+    } catch {}
+    return;
+  }
+  // ── NOTE list ──
+  if (action === 'note_list') {
+    try {
+      const { getNotes } = await import('./notes.mjs').catch(() => ({}));
+      if (getNotes) {
+        const notes = getNotes();
+        const items = (notes || []).map(n => ({ id: n.id, title: n.title, body: n.body?.slice(0, 200) }));
+        rememberList(chatId, 'note', items);
+      }
+    } catch {}
+    return;
+  }
+  // ── REMINDER list ──
+  if (action === 'reminder_list') {
+    try {
+      const { listReminders } = await import('./reminders.mjs').catch(() => ({}));
+      if (listReminders) {
+        const arr = listReminders();
+        const items = (arr || []).map(r => ({ id: r.id, message: r.message, when: r.when }));
+        rememberList(chatId, 'reminder', items);
+      }
+    } catch {}
+    return;
+  }
+  // ── NOTION search ──
+  if (action === 'notion_search') {
+    try {
+      // Notion search returns pages — we parse from the textual result as
+      // a best-effort, falling back to whatever ID hints the result contains.
+      const m = String(result).match(/[a-f0-9]{32}|[a-f0-9-]{36}/g);
+      if (m && m.length > 0) {
+        const items = m.slice(0, 10).map(id => ({ id, pageId: id }));
+        rememberList(chatId, 'notion', items);
+      }
+    } catch {}
+    return;
+  }
+  // ── SLACK search ──
+  if (action === 'slack_search') {
+    try {
+      const m = String(result).match(/\b(\d{10}\.\d{6})\b/g);
+      if (m && m.length > 0) {
+        const items = m.slice(0, 10).map(ts => ({ id: ts, ts }));
+        rememberList(chatId, 'slack', items);
+      }
+    } catch {}
+    return;
+  }
+  // ── GITHUB issue/PR list ──
+  if (action === 'github_list_issues' || action === 'github_issues' || action === 'github_prs' || action === 'github_pulls') {
+    try {
+      // Best effort from result text: lines like "#123 Title"
+      const matches = [...String(result).matchAll(/#(\d+)\s+(.+)/g)];
+      if (matches.length > 0) {
+        const items = matches.slice(0, 20).map(m => ({ id: m[1], number: parseInt(m[1], 10), title: m[2].trim() }));
+        rememberList(chatId, 'github', items);
+      }
+    } catch {}
+    return;
+  }
+}
+
 export async function executeTool(action, params, config) {
   switch (action) {
     // ── Gmail ──────────────────────────────────────────────────────────────