nothumanallowed 16.0.15 → 16.0.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nothumanallowed",
-  "version": "16.0.15",
+  "version": "16.0.17",
   "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.15';
+export const VERSION = '16.0.17';
 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

@@ -1160,19 +1160,42 @@ class TelegramResponder {
         // appointments of May". By running the calendar tool server-side, the
         // user always sees REAL data — never fabricated.
         this._lastDirectAuditChatId = chatId;
+
+        // ── UNIVERSAL ANAPHORIC PRE-STEP (v16.0.17) ──
+        // Same logic as tryDirectActionAll on the chat web: intercept
+        // anaphoric commands ("cancellalo", "il primo", "si") BEFORE the
+        // per-domain handlers, since the calendar regex doesn't catch
+        // pronouns and the LLM otherwise hallucinates.
+        let directFresh = null;
+        try {
+          const anaphor = this._detectAnaphoricAction(cleanText);
+          if (anaphor) {
+            const resolved = this._resolveAnaphoric(null, cleanText);
+            if (resolved?.item) {
+              directFresh = await this._executeAnaphoricVerb(anaphor, resolved.kind, resolved.item, cleanText, this.config);
+            } else {
+              this.log(`[Telegram] anaphoric verb=${anaphor} but no item to resolve`);
+            }
+          }
+        } catch (e) {
+          this.log(`[Telegram] anaphoric dispatcher error: ${e.message}`);
+        }
+
         // 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._tryDirectFreshUniversalAction(cleanText, this.config);
+        if (!directFresh) {
+          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._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 || '';
@@ -1486,6 +1509,204 @@ 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
@@ -1502,7 +1723,14 @@ class TelegramResponder {
       return { from, to: new Date(from.getTime() + 86400000) };
     }
     if (toolName === 'calendar_week') {
-      const from = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+      // Respect optional startDate (e.g. for "settimana prossima").
+      let from;
+      if (args?.startDate && /^\d{4}-\d{2}-\d{2}$/.test(args.startDate)) {
+        const [yy, mm, dd] = args.startDate.split('-').map(n => parseInt(n, 10));
+        from = new Date(yy, mm - 1, dd);
+      } else {
+        from = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+      }
       return { from, to: new Date(from.getTime() + 7 * 86400000) };
     }
     if (toolName === 'calendar_month') {
@@ -2345,6 +2573,26 @@ class TelegramResponder {
         return await runListAndRemember('calendar_today', {}, 'calendar_today');
       if (/\b(domani|tomorrow)\b/.test(lower))
         return await runListAndRemember('calendar_tomorrow', {}, 'calendar_tomorrow');
+      // "settimana prossima / next week / settimana che viene" → calendar_week
+      // starting next Monday. Without this offset, calendar_week always shows
+      // the CURRENT week, which is wrong for "settimana prossima" and lets
+      // the LLM hallucinate a fake list of upcoming events.
+      if (/\b(settimana\s+(prossima|che\s+viene|seguente)|next\s+week|prossima\s+settimana)\b/.test(lower)) {
+        const today = new Date();
+        const dayOfWeek = today.getDay(); // 0=sun..6=sat
+        const daysUntilMonday = ((1 - dayOfWeek + 7) % 7) || 7;
+        const nextMonday = new Date(today.getFullYear(), today.getMonth(), today.getDate() + daysUntilMonday);
+        const startDate = nextMonday.toISOString().slice(0, 10);
+        return await runListAndRemember('calendar_week', { startDate }, 'calendar_week_next');
+      }
+      if (/\b(settimana\s+scorsa|last\s+week|scorsa\s+settimana)\b/.test(lower)) {
+        const today = new Date();
+        const dayOfWeek = today.getDay();
+        const daysToLastMonday = (dayOfWeek === 0 ? 6 : dayOfWeek - 1) + 7;
+        const lastMonday = new Date(today.getFullYear(), today.getMonth(), today.getDate() - daysToLastMonday);
+        const startDate = lastMonday.toISOString().slice(0, 10);
+        return await runListAndRemember('calendar_week', { startDate }, 'calendar_week_last');
+      }
       if (/\b(settimana|week|questa\s+settimana|this\s+week)\b/.test(lower))
         return await runListAndRemember('calendar_week', {}, 'calendar_week');
       const monthMatch = lower.match(new RegExp(`\\b(${Object.keys(MONTH_MAP).join('|')})(?:\\s+(20\\d{2}))?\\b`));
@@ -2565,6 +2813,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 ──────────────────────────────────────────────────────────────