nothumanallowed 16.0.10 → 16.0.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nothumanallowed",
-  "version": "16.0.10",
+  "version": "16.0.12",
   "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/cli.mjs

@@ -18,6 +18,7 @@ import { cmdUI } from './commands/ui.mjs';
 import { cmdGoogle } from './commands/google-auth.mjs';
 import { cmdMicrosoft } from './commands/microsoft-auth.mjs';
 import { cmdScan } from './commands/scan.mjs';
+import { runMemory } from './commands/memory.mjs';
 import { cmdVoice } from './commands/voice.mjs';
 import { cmdPlugin, findPluginForCommand } from './commands/plugin.mjs';
 import { banner, info, ok, warn, fail, C, G, Y, D, W, BOLD, NC, M, B, R } from './ui.mjs';
@@ -86,6 +87,11 @@ export async function main(argv) {
     case 'task':
       return cmdTasks(args);
 
+    case 'memory':
+    case 'memorize':
+    case 'remember':
+      return runMemory(args);
+
     case 'ops':
       return cmdOps(args);
 

package/src/commands/memory.mjs

@@ -0,0 +1,70 @@
+/**
+ * `nha memory` — manage persistent user memory.
+ *
+ * Subcommands:
+ *   nha memory add "..."      append a fact
+ *   nha memory list           print current memory
+ *   nha memory edit           open the memory file in $EDITOR
+ *   nha memory clear          wipe everything (with confirmation)
+ *   nha memory path           print the memory file path
+ */
+
+import {
+  addUserMemory,
+  loadUserMemory,
+  clearUserMemory,
+  getMemoryPath,
+} from '../services/user-memory.mjs';
+import { spawn } from 'child_process';
+
+export async function runMemory(args) {
+  const sub = args[0];
+
+  if (!sub || sub === 'list' || sub === 'show') {
+    const text = loadUserMemory();
+    if (!text.trim()) {
+      console.log('Memory empty. Add something with: nha memory add "..."');
+    } else {
+      console.log(text);
+    }
+    return;
+  }
+
+  if (sub === 'add') {
+    const entry = args.slice(1).join(' ').trim();
+    if (!entry) {
+      console.error('Usage: nha memory add "Fact to remember"');
+      process.exit(1);
+    }
+    addUserMemory(entry);
+    console.log(`✓ Added to memory: ${entry}`);
+    return;
+  }
+
+  if (sub === 'edit') {
+    const editor = process.env.EDITOR || process.env.VISUAL || 'nano';
+    const proc = spawn(editor, [getMemoryPath()], { stdio: 'inherit' });
+    proc.on('close', (code) => process.exit(code || 0));
+    return;
+  }
+
+  if (sub === 'clear') {
+    const confirm = args.includes('--yes') || args.includes('-y');
+    if (!confirm) {
+      console.error('This will wipe ALL stored memories. Re-run with --yes to confirm.');
+      process.exit(1);
+    }
+    clearUserMemory();
+    console.log('✓ Memory cleared.');
+    return;
+  }
+
+  if (sub === 'path') {
+    console.log(getMemoryPath());
+    return;
+  }
+
+  console.error(`Unknown subcommand: ${sub}`);
+  console.error('Usage: nha memory <add|list|edit|clear|path>');
+  process.exit(1);
+}

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.10';
+export const VERSION = '16.0.12';
 export const BASE_URL = 'https://nothumanallowed.com/cli';
 export const API_BASE = 'https://nothumanallowed.com/api/v1';
 

package/src/server/routes/chat.mjs

@@ -219,32 +219,75 @@ export function register(router) {
       enrichedPrompt += `\n\nIMPORTANT: Output language is ${userLang}. Do NOT switch languages mid-response.`;
     }
 
-    // Rolling context window
+    // ── Conversation history → structured messages[] (Fix 1, v16.0.12) ──
+    // ChatGPT/Claude pass full history as messages[]. We do the same: each
+    // turn keeps its own {role, content} so the model sees a real
+    // conversation, not a concatenated string. The rolling SUMMARY of older
+    // turns (Fix 2) is injected as a context prefix in the system prompt.
     const rawHistory = (body.history || []).map(h => ({
-      role: h.role,
+      role: h.role === 'assistant' ? 'assistant' : 'user',
       content: (h.content || '').replace(/!\[Screenshot\]\(data:image\/[^)]+\)/g, '[Screenshot taken]'),
-    }));
-    const RECENT = 6;
-    const parts = [];
+    })).filter(m => m.content);
+
+    // ── Rolling summary (Fix 2) ──
+    // After a threshold of turns we generate (or reuse) a compact summary of
+    // everything OLDER than the recent window, persisted in the conversation
+    // object. The recent window stays as raw messages[]. This is the
+    // "memory like ChatGPT/Claude" pattern.
+    const RECENT = 12;
+    let conversationSummary = '';
+    let recentHistory = rawHistory;
     if (rawHistory.length > RECENT) {
+      recentHistory = rawHistory.slice(-RECENT);
       const older = rawHistory.slice(0, -RECENT);
-      const lines = [];
-      for (let i = 0; i < older.length; i += 2) {
-        const u = older[i]?.content?.slice(0, 150)?.replace(/\n/g, ' ') || '';
-        const a = older[i+1]?.content?.slice(0, 200)?.replace(/\n/g, ' ') || '';
-        if (u) lines.push(`- User: "${u.trim()}${u.length >= 150 ? '...' : ''}" → ${a.trim()}${a.length >= 200 ? '...' : ''}`);
+      // Try to reuse a cached summary from the conversation, regenerate if
+      // the older slice grew beyond what the cached summary covered.
+      let cachedConv = null;
+      if (body.conversationId) {
+        try { cachedConv = loadConversation(body.conversationId); } catch {}
+      }
+      const cached = cachedConv?.rollingSummary;
+      if (cached && cached.coveredTurns === older.length) {
+        conversationSummary = cached.text;
+      } else {
+        // Generate a fresh summary via the same LLM. Compact, factual.
+        const summaryInput = older.map(m =>
+          `${m.role === 'user' ? 'Utente' : 'Assistente'}: ${m.content.slice(0, 600)}`
+        ).join('\n\n');
+        try {
+          conversationSummary = await callLLM(
+            config,
+            'Sei un sintetizzatore di conversazione. Riassumi in italiano in 200-400 token TUTTI i fatti, decisioni, preferenze utente, dati specifici (date, ID, nomi, numeri) emersi nella conversazione. Niente abbellimenti, solo informazione utile per ricostruire il contesto.',
+            summaryInput,
+            { max_tokens: 600, temperature: 0.2 },
+          );
+          if (cachedConv) {
+            cachedConv.rollingSummary = { text: conversationSummary, coveredTurns: older.length, at: new Date().toISOString() };
+            try { saveConversation(cachedConv); } catch {}
+          }
+        } catch { /* if summary fails, just skip it — recent history is enough */ }
       }
-      if (lines.length) parts.push(`[CONVERSATION CONTEXT]\n${lines.join('\n')}\n[END CONTEXT]`);
     }
-    for (const t of rawHistory.slice(-RECENT)) {
-      parts.push(`${t.role === 'user' ? '[User]' : '[Assistant]'} ${t.content.slice(0, 2000)}`);
+
+    // Inject summary into the system prompt — it's the cheapest way for the
+    // model to see it AND it benefits from prompt caching on Anthropic.
+    if (conversationSummary) {
+      effectiveSystemPrompt = `${effectiveSystemPrompt || ''}\n\n[CONTESTO CONVERSAZIONE PRECEDENTE]\n${conversationSummary}\n[FINE CONTESTO]`;
     }
-    // Prefix the last user turn with an explicit per-message language tag.
-    // System prompts can lose effectiveness over long conversations; the
-    // per-turn tag is the closest hint to the model's first generated token
-    // and is the most reliable trigger for the right language.
-    parts.push(`[User · respond in ${userLang}] ${effectiveMsg}`);
-    const userMessage = parts.join('\n\n');
+
+    // ── User memory (Fix 3) — persistent across conversations + channels ──
+    // Loaded from ~/.nha/user-memory.md, prepended to the system prompt.
+    try {
+      const { buildMemoryPrefix } = await import('../../services/user-memory.mjs');
+      const memPrefix = buildMemoryPrefix();
+      if (memPrefix) effectiveSystemPrompt = `${memPrefix}${effectiveSystemPrompt || ''}`;
+    } catch {}
+
+    // The final user message — keep the per-turn language tag close to the
+    // model's first generated token.
+    const userMessage = `[User · respond in ${userLang}] ${effectiveMsg}`;
+    // History passed to the provider as proper messages[] (not concatenated).
+    const historyForLLM = recentHistory;
 
     // Attachments — handle non-streaming
     if (body.imageBase64 || body.pdfBase64 || body.fileContent) {
@@ -298,7 +341,7 @@ export function register(router) {
         clearInterval(heartbeatInterval);
         heartbeatInterval = null;
         sse('token', { content: chunk });
-      });
+      }, { history: historyForLLM });
 
       const { textParts, actions } = parseActions(fullResponse);
       const toolResults = [];

package/src/services/llm.mjs

@@ -399,11 +399,18 @@ export async function callAnthropic(apiKey, model, systemPrompt, userMessage, st
   const systemBlocks = systemPrompt
     ? [{ type: 'text', text: systemPrompt, cache_control: { type: 'ephemeral' } }]
     : [];
+  // Build conversation messages: optional history[] then the current turn.
+  // history must alternate role: user/assistant/user/... ending with assistant
+  // (or be empty). The current userMessage is appended as the final user turn.
+  const historyMsgs = Array.isArray(opts.history)
+    ? opts.history.filter(m => m && m.role && m.content).map(m => ({ role: m.role, content: String(m.content) }))
+    : [];
+  const messages = [...historyMsgs, { role: 'user', content: userMessage }];
   const body = {
     model: model || 'claude-sonnet-4-20250514',
     max_tokens: opts.max_tokens || 8192,
     system: systemBlocks,
-    messages: [{ role: 'user', content: userMessage }],
+    messages,
     stream,
   };
   if (opts.temperature !== undefined) body.temperature = opts.temperature;
@@ -427,11 +434,15 @@ export async function callAnthropic(apiKey, model, systemPrompt, userMessage, st
 }
 
 export async function callOpenAI(apiKey, model, systemPrompt, userMessage, stream = false, opts = {}) {
+  const historyMsgs = Array.isArray(opts.history)
+    ? opts.history.filter(m => m && m.role && m.content).map(m => ({ role: m.role, content: String(m.content) }))
+    : [];
   const body = {
     model: model || 'gpt-4o',
     max_tokens: opts.max_tokens || 8192,
     messages: [
       { role: 'system', content: systemPrompt },
+      ...historyMsgs,
       { role: 'user', content: userMessage },
     ],
     stream,
@@ -459,9 +470,16 @@ export async function callGemini(apiKey, model, systemPrompt, userMessage, _stre
   const url = `https://generativelanguage.googleapis.com/v1beta/models/${m}:generateContent?key=${apiKey}`;
   const generationConfig = { maxOutputTokens: opts.max_tokens || 8192 };
   if (opts.temperature !== undefined) generationConfig.temperature = opts.temperature;
+  // Gemini uses 'contents' with role 'user'/'model'. Convert history.
+  const historyContents = Array.isArray(opts.history)
+    ? opts.history.filter(m => m && m.role && m.content).map(m => ({
+        role: m.role === 'assistant' ? 'model' : 'user',
+        parts: [{ text: String(m.content) }],
+      }))
+    : [];
   const body = {
     system_instruction: { parts: [{ text: systemPrompt }] },
-    contents: [{ parts: [{ text: userMessage }] }],
+    contents: [...historyContents, { role: 'user', parts: [{ text: userMessage }] }],
     generationConfig,
   };
   const res = await fetch(url, {
@@ -664,11 +682,18 @@ export async function callNHA(apiKey, model, systemPrompt, userMessage, stream =
     .replace(/\|\|\(/g, '||(')                  // LDAP (cosmetic, non-breaking)
     .replace(/\)\|\|/g, ')||');                 // LDAP
 
+  const historyMsgs = Array.isArray(opts.history)
+    ? opts.history.filter(m => m && m.role && m.content).map(m => ({
+        role: m.role === 'assistant' ? 'assistant' : 'user',
+        content: sanitizeForSentinel(String(m.content)),
+      }))
+    : [];
   const body = {
     model: model || '/opt/models/qwen3-32b',
     max_tokens: opts.max_tokens || (thinkingEnabled ? 16384 : 8192),
     messages: [
       { role: 'system', content: sanitizeForSentinel(systemPrompt) },
+      ...historyMsgs,
       { role: 'user', content: sanitizeForSentinel(userMessage) },
     ],
     stream,
@@ -1212,11 +1237,18 @@ export async function callLLMStream(config, systemPrompt, userMessage, onToken,
     // 3. Otherwise default to 8192 (full context for specialist agents)
     const effectiveMaxTokens = opts.max_tokens || (thinkingEnabled ? 8192 : 8192);
 
+    const nhaHistory = Array.isArray(opts.history)
+      ? opts.history.filter(m => m && m.role && m.content).map(m => ({
+          role: m.role === 'assistant' ? 'assistant' : 'user',
+          content: sanitize(String(m.content)),
+        }))
+      : [];
     const nhaBody = {
       model: model || '/opt/models/qwen3-32b',
       max_tokens: effectiveMaxTokens,
       messages: [
         { role: 'system', content: sanitize(systemPrompt) },
+        ...nhaHistory,
         { role: 'user', content: sanitize(userMessage) },
       ],
       stream: false,

package/src/services/message-responder.mjs

@@ -18,6 +18,28 @@ import path from 'path';
 import os from 'os';
 import { VERSION } from '../constants.mjs';
 
+// ── Global audit log helpers (Fix 4 v16.0.12) ──
+// Append-only JSONL at ~/.nha/audit-log.jsonl, shared across every channel
+// (telegram, discord, chat web, AWF agents). Lets the user ask "what have you
+// done today?" from any surface and get a consistent answer.
+const _GLOBAL_AUDIT_FILE = path.join(os.homedir(), '.nha', 'audit-log.jsonl');
+function _appendGlobalAudit(entry) {
+  try {
+    fs.mkdirSync(path.dirname(_GLOBAL_AUDIT_FILE), { recursive: true });
+    fs.appendFileSync(_GLOBAL_AUDIT_FILE, JSON.stringify(entry) + '\n');
+  } catch {}
+}
+function _readGlobalAudit(limitTail = 100) {
+  try {
+    if (!fs.existsSync(_GLOBAL_AUDIT_FILE)) return [];
+    const text = fs.readFileSync(_GLOBAL_AUDIT_FILE, 'utf-8');
+    const lines = text.split('\n').filter(Boolean);
+    return lines.slice(-limitTail)
+      .map(l => { try { return JSON.parse(l); } catch { return null; } })
+      .filter(Boolean);
+  } catch { return []; }
+}
+
 // ── Agent Routing (keyword-based, zero LLM calls) ───────────────────────────
 
 const ROUTING_TABLE = [
@@ -1449,21 +1471,43 @@ class TelegramResponder {
   _recordAudit(chatId, entry) {
     const ctx = this._lastContextByChatId[chatId] || (this._lastContextByChatId[chatId] = {});
     if (!Array.isArray(ctx.auditLog)) ctx.auditLog = [];
-    ctx.auditLog.push({ ts: Date.now(), ...entry });
+    const enriched = { ts: Date.now(), channel: chatId, ...entry };
+    ctx.auditLog.push(enriched);
     if (ctx.auditLog.length > 50) ctx.auditLog = ctx.auditLog.slice(-50);
     this._persistContext();
+    // ── Global audit log (Fix 4 v16.0.12) ──
+    // Append-only JSONL at ~/.nha/audit-log.jsonl shared across every channel
+    // (telegram / discord / chat web / AWF agent). Lets the user ask
+    // "what have you done today?" from any surface and get the same answer.
+    try {
+      _appendGlobalAudit(enriched);
+    } catch {}
   }
 
   _renderAuditForPrompt(chatId, maxEntries = 10) {
+    // Pull from BOTH the per-channel context AND the global log so the model
+    // sees actions made via a different channel too.
     const ctx = this._lastContextByChatId[chatId];
-    if (!ctx || !Array.isArray(ctx.auditLog) || ctx.auditLog.length === 0) return '';
-    const recent = ctx.auditLog.slice(-maxEntries);
+    const local = ctx?.auditLog || [];
+    let globalEntries = [];
+    try { globalEntries = _readGlobalAudit(100); } catch {}
+    // Merge + de-dupe by (ts, tool, summary), keep most recent.
+    const seen = new Set();
+    const merged = [...local, ...globalEntries].sort((a, b) => a.ts - b.ts).filter(e => {
+      const k = `${e.ts}|${e.tool}|${e.summary || ''}`;
+      if (seen.has(k)) return false;
+      seen.add(k);
+      return true;
+    });
+    if (merged.length === 0) return '';
+    const recent = merged.slice(-maxEntries);
     const lines = recent.map(e => {
       const time = new Date(e.ts).toLocaleString('it-IT', { day: '2-digit', month: 'short', hour: '2-digit', minute: '2-digit' });
       const status = e.success === false ? '✗ FALLITA' : '✓ OK';
-      return `- ${time} · ${e.tool} · ${status} · ${e.summary || ''}`;
+      const chan = e.channel && e.channel !== chatId ? ` [via ${String(e.channel).slice(0, 20)}]` : '';
+      return `- ${time} · ${e.tool} · ${status} · ${e.summary || ''}${chan}`;
     });
-    return `\n\n[AZIONI RECENTI ESEGUITE IN QUESTA CONVERSAZIONE — fonte di verità sui fatti già accaduti]\n${lines.join('\n')}\n[FINE AZIONI RECENTI]\n`;
+    return `\n\n[AZIONI RECENTI ESEGUITE — fonte di verità sui fatti già accaduti su QUALSIASI canale (Chat, Telegram, Discord, AWF)]\n${lines.join('\n')}\n[FINE AZIONI RECENTI]\n`;
   }
 
   _formatDateIT(isoDate) {
@@ -1908,6 +1952,52 @@ class TelegramResponder {
   async _tryDirectFreshCalendarAction(userMessage, config) {
     if (!userMessage || typeof userMessage !== 'string') return null;
     const lower = userMessage.toLowerCase().normalize('NFD').replace(/[̀-ͯ]/g, '');
+    const chatId = this._lastDirectAuditChatId;
+    const { executeTool: _executeToolPre } = await import('./tool-executor.mjs');
+
+    // ─── ANAPHORIC delete + CONFIRMATION yes ────────────────────────────────
+    // If the previous turn ran a LIST/LAST-SHOWN and the user now says
+    // "cancellalo / eliminalo / quello / si / conferma / fallo", resolve the
+    // referent from this._lastContextByChatId[chatId].lastCalendarEvents.
+    const isAnaphoric = /\b(cancell|elimin|rimuov)[aeiloy]+(lo|la|li|le|gli)?\b/.test(lower)
+      && !this._extractCalendarProposal(userMessage).date
+      && !this._extractCalendarProposal(userMessage).title;
+    const isYesConfirm = /^\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(userMessage.trim());
+    if (chatId && (isAnaphoric || isYesConfirm)) {
+      const ctx = this._lastContextByChatId[chatId] || {};
+      const pendingEvents = ctx.lastCalendarEvents || ctx.pendingDeleteEvents || [];
+      // Strict: only auto-execute if the previous turn LIST/proposal had a
+      // single deletable event, or if pendingDelete is explicitly set.
+      const eligible = ctx.pendingDeleteEvents && ctx.pendingDeleteEvents.length > 0
+        ? ctx.pendingDeleteEvents
+        : (pendingEvents.length === 1 ? pendingEvents : null);
+      if (eligible && eligible.length > 0) {
+        let ok = 0, ko = 0;
+        const failed = [];
+        for (const ev of eligible) {
+          if (!ev.eventId) { ko++; failed.push(ev.summary || '(no id)'); continue; }
+          try {
+            await _executeToolPre('calendar_delete', { eventId: ev.eventId }, config);
+            ok++;
+          } catch (e) {
+            ko++;
+            failed.push(`${ev.summary || ev.eventId} (${e.message?.slice(0, 60) || 'err'})`);
+          }
+        }
+        // Clear the pending state so we don't double-delete on next yes.
+        delete this._lastContextByChatId[chatId].pendingDeleteEvents;
+        delete this._lastContextByChatId[chatId].lastCalendarEvents;
+        try { (await import('./telegram-context.mjs')).saveTelegramContext(this._lastContextByChatId); } catch {}
+
+        const subject = eligible.length === 1 ? `"${eligible[0].summary}"` : `${eligible.length} appuntamenti`;
+        const lines = [`Ho cancellato ${subject}.`];
+        if (ko > 0) lines.push(`Non sono riuscito a cancellarne ${ko}: ${failed.slice(0, 3).join(', ')}`);
+        this._recordAudit(chatId, { tool: 'calendar_delete', success: ok > 0, summary: `cancellati ${ok}` });
+        return { action: 'calendar_delete', success: ok > 0, message: lines.join('\n') };
+      }
+      // No eligible referent — fall through; the LLM will ask for clarification.
+    }
+
 
     const MONTHS_IT = { gennaio:1, febbraio:2, marzo:3, aprile:4, maggio:5, giugno:6, luglio:7, agosto:8, settembre:9, ottobre:10, novembre:11, dicembre:12 };
     const MONTHS_EN = { january:1, february:2, march:3, april:4, may:5, june:6, july:7, august:8, september:9, october:10, november:11, december:12, jan:1, feb:2, mar:3, apr:4, jun:6, jul:7, aug:8, sep:9, oct:10, nov:11, dec:12 };
@@ -2090,54 +2180,44 @@ class TelegramResponder {
 
     // ─── LIST intents ──────────────────────────────────────────────────────
     if (isList && !isDelete && !isVerify && !isCreate && !isMove) {
-      // "appuntamenti di oggi"
-      if (/\b(oggi|today)\b/.test(lower)) {
-        try {
-          const out = await executeTool('calendar_today', {}, config);
-          return { action: 'calendar_today', success: true, message: String(out) };
-        } catch (e) { return { action: 'calendar_today', success: false, message: `Errore: ${e.message}` }; }
-      }
-      // "appuntamenti di domani"
-      if (/\b(domani|tomorrow)\b/.test(lower)) {
+      // Helper that runs the tool, parses the events and remembers them for
+      // anaphoric resolution in the NEXT turn ("cancellalo", "spostali tutti").
+      const runListAndRemember = async (toolName, args, actionKey) => {
         try {
-          const out = await executeTool('calendar_tomorrow', {}, config);
-          return { action: 'calendar_tomorrow', success: true, message: String(out) };
-        } catch (e) { return { action: 'calendar_tomorrow', success: false, message: `Errore: ${e.message}` }; }
-      }
-      // "appuntamenti della settimana"
-      if (/\b(settimana|week|questa\s+settimana|this\s+week)\b/.test(lower)) {
-        try {
-          const out = await executeTool('calendar_week', {}, config);
-          return { action: 'calendar_week', success: true, message: String(out) };
-        } catch (e) { return { action: 'calendar_week', success: false, message: `Errore: ${e.message}` }; }
-      }
-      // "appuntamenti di maggio" — month name + optional year
+          const out = await executeTool(toolName, args, config);
+          const events = this._parseEventsFromToolOutput(String(out));
+          if (chatId) {
+            const prev = this._lastContextByChatId[chatId] || {};
+            this._lastContextByChatId[chatId] = {
+              ...prev,
+              lastCalendarEvents: events,
+              lastCalendarListAt: Date.now(),
+              lastCalendarSource: { tool: toolName, args },
+            };
+            try { (await import('./telegram-context.mjs')).saveTelegramContext(this._lastContextByChatId); } catch {}
+          }
+          return { action: actionKey, success: true, message: String(out) };
+        } catch (e) { return { action: actionKey, success: false, message: `Errore: ${e.message}` }; }
+      };
+
+      if (/\b(oggi|today)\b/.test(lower))
+        return await runListAndRemember('calendar_today', {}, 'calendar_today');
+      if (/\b(domani|tomorrow)\b/.test(lower))
+        return await runListAndRemember('calendar_tomorrow', {}, 'calendar_tomorrow');
+      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`));
       if (monthMatch) {
         const monthNum = MONTH_MAP[monthMatch[1]];
         const yearNum = parseInt(monthMatch[2] || String(new Date().getFullYear()), 10);
-        // calendar_month accepts a month string like "2026-05"
         const monthStr = `${yearNum}-${String(monthNum).padStart(2, '0')}`;
-        try {
-          const out = await executeTool('calendar_month', { month: monthStr }, config);
-          return { action: 'calendar_month', success: true, message: String(out) };
-        } catch (e) { return { action: 'calendar_month', success: false, message: `Errore: ${e.message}` }; }
+        return await runListAndRemember('calendar_month', { month: monthStr }, 'calendar_month');
       }
-      // "appuntamenti del 15 maggio" — specific date
       const dateExtracted = this._extractCalendarProposal(userMessage);
-      if (dateExtracted.date) {
-        try {
-          const out = await executeTool('calendar_date', { date: dateExtracted.date }, config);
-          return { action: 'calendar_date', success: true, message: String(out) };
-        } catch (e) { return { action: 'calendar_date', success: false, message: `Errore: ${e.message}` }; }
-      }
-      // Generic "appuntamenti prossimi" → upcoming 48h
-      if (/\b(prossim|next|upcoming|in\s+arrivo)/.test(lower)) {
-        try {
-          const out = await executeTool('calendar_upcoming', { hours: 48 }, config);
-          return { action: 'calendar_upcoming', success: true, message: String(out) };
-        } catch (e) { return { action: 'calendar_upcoming', success: false, message: `Errore: ${e.message}` }; }
-      }
+      if (dateExtracted.date)
+        return await runListAndRemember('calendar_date', { date: dateExtracted.date }, 'calendar_date');
+      if (/\b(prossim|next|upcoming|in\s+arrivo)/.test(lower))
+        return await runListAndRemember('calendar_upcoming', { hours: 48 }, 'calendar_upcoming');
       // Fall through — let the LLM handle ambiguous list requests.
     }
 

package/src/services/user-memory.mjs

@@ -0,0 +1,80 @@
+/**
+ * User memory — persistent across conversations and channels.
+ *
+ * Same idea as ChatGPT's "Memory" feature: a small Markdown file at
+ * ~/.nha/user-memory.md is loaded and prepended to the system prompt of
+ * every chat / Telegram / Discord / AWF agent call.
+ *
+ * The file is fully owned by the user — no telemetry, never uploaded.
+ * Stored as plain Markdown so it stays human-readable and editable.
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { NHA_DIR } from '../constants.mjs';
+
+const MEMORY_FILE = path.join(NHA_DIR, 'user-memory.md');
+const MAX_MEMORY_SIZE = 8000; // chars — prevents prompt explosion
+
+function ensureFile() {
+  if (!fs.existsSync(NHA_DIR)) fs.mkdirSync(NHA_DIR, { recursive: true });
+  if (!fs.existsSync(MEMORY_FILE)) {
+    const header = `# User Memory\n\n` +
+      `Things NHA should remember about you, across all conversations and channels.\n` +
+      `Edit this file freely, or use \`nha memory add "..."\` to append.\n\n`;
+    fs.writeFileSync(MEMORY_FILE, header);
+  }
+}
+
+/** Load the full memory file content (trimmed to MAX size). */
+export function loadUserMemory() {
+  try {
+    if (!fs.existsSync(MEMORY_FILE)) return '';
+    const text = fs.readFileSync(MEMORY_FILE, 'utf-8');
+    if (text.length <= MAX_MEMORY_SIZE) return text;
+    // Keep the most recent entries (tail) if it grows too large.
+    return text.slice(-MAX_MEMORY_SIZE);
+  } catch { return ''; }
+}
+
+/** Append a single fact/preference to the memory file. */
+export function addUserMemory(entry) {
+  if (!entry || typeof entry !== 'string') return false;
+  ensureFile();
+  const trimmed = entry.trim();
+  if (!trimmed) return false;
+  const timestamp = new Date().toISOString().slice(0, 10);
+  const line = `- [${timestamp}] ${trimmed}\n`;
+  fs.appendFileSync(MEMORY_FILE, line);
+  return true;
+}
+
+/** Replace the entire memory content (used by `nha memory edit`). */
+export function setUserMemory(text) {
+  ensureFile();
+  fs.writeFileSync(MEMORY_FILE, text);
+}
+
+/** Wipe all memories. */
+export function clearUserMemory() {
+  if (fs.existsSync(MEMORY_FILE)) fs.unlinkSync(MEMORY_FILE);
+}
+
+/** Get the memory file path (for the `nha memory edit` command to open). */
+export function getMemoryPath() {
+  return MEMORY_FILE;
+}
+
+/**
+ * Build a system-prompt prefix block for the user memory. Returns empty
+ * string when there's nothing to inject (no file, or only the header).
+ * The prefix is wrapped in delimited markers so it doesn't bleed into
+ * the rest of the prompt and the model knows it's persistent context.
+ */
+export function buildMemoryPrefix() {
+  const raw = loadUserMemory().trim();
+  if (!raw || raw.replace(/^#.*$/gm, '').replace(/^Things NHA.*$/gm, '').trim().length === 0) {
+    return '';
+  }
+  return `[USER MEMORY — persistent across all conversations]\n${raw}\n[END USER MEMORY]\n\n`;
+}