nothumanallowed 15.1.10 → 15.1.11

package/package.json

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

package/src/services/message-responder.mjs

@@ -374,6 +374,40 @@ async function checkNpmVersion() {
 
 // ── Telegram Bot (Long Polling via native fetch) ─────────────────────────────
 
+// Persistent storage for per-chat conversational state. Without this, every
+// process restart (npm self-update, crash, "nha ops stop && start") loses the
+// sticky-agent + turn history, and the user's next "Procedi" / "Si" routes
+// to a random agent because the planner has no thread to anchor on.
+const TELEGRAM_CTX_FILE = path.join(os.homedir(), '.nha', 'telegram-context.json');
+const TELEGRAM_CTX_MAX_AGE_MS = 30 * 60 * 1000; // 30 min — older than that, discard
+
+function loadTelegramContext() {
+  try {
+    if (!fs.existsSync(TELEGRAM_CTX_FILE)) return {};
+    const raw = JSON.parse(fs.readFileSync(TELEGRAM_CTX_FILE, 'utf-8'));
+    const now = Date.now();
+    const fresh = {};
+    for (const [chatId, ctx] of Object.entries(raw)) {
+      if (ctx && typeof ctx.ts === 'number' && (now - ctx.ts) < TELEGRAM_CTX_MAX_AGE_MS) {
+        fresh[chatId] = ctx;
+      }
+    }
+    return fresh;
+  } catch { return {}; }
+}
+
+function saveTelegramContext(byChatId) {
+  try {
+    const dir = path.dirname(TELEGRAM_CTX_FILE);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    // Atomic write — temp file + rename so a crash during write doesn't leave
+    // half-written JSON that breaks the next boot.
+    const tmp = TELEGRAM_CTX_FILE + '.tmp';
+    fs.writeFileSync(tmp, JSON.stringify(byChatId, null, 2));
+    fs.renameSync(tmp, TELEGRAM_CTX_FILE);
+  } catch { /* non-fatal */ }
+}
+
 class TelegramResponder {
   constructor(config, log, wsBroadcast) {
     this.config = config;
@@ -389,9 +423,25 @@ class TelegramResponder {
     this.maxConcurrent = 3;
     this._updateCheckTimer = null;
     this._lastNotifiedVersion = null;
-    // Per-chat sticky agent: remembers last agent used, plus last turn context
-    this._lastAgentByChatId = {};       // chatId → agentName
-    this._lastContextByChatId = {};     // chatId → { agent, userMsg, agentReply, ts }
+    // Per-chat sticky agent — restored from disk so self-restarts and npm
+    // updates don't break in-flight conversations.
+    this._lastContextByChatId = loadTelegramContext();
+    this._lastAgentByChatId = {};
+    for (const [chatId, ctx] of Object.entries(this._lastContextByChatId)) {
+      if (ctx && ctx.agent) this._lastAgentByChatId[chatId] = ctx.agent;
+    }
+    const restoredCount = Object.keys(this._lastContextByChatId).length;
+    if (restoredCount > 0) {
+      this.log(`[Telegram] Restored conversational context for ${restoredCount} chat(s) from disk`);
+    }
+    this._saveCtxTimer = null;
+  }
+
+  _persistContext() {
+    // Synchronous write — guarantees the context is on disk even if the
+    // process exits immediately after (npm self-update, SIGTERM, crash).
+    // The file is tiny (< 10 KB typical), so this stays sub-millisecond.
+    saveTelegramContext(this._lastContextByChatId);
   }
 
   get enabled() {
@@ -718,6 +768,10 @@ class TelegramResponder {
         ts: Date.now(),
       };
       this._lastAgentByChatId[chatId] = agent;
+      // Persist to disk so the context survives npm self-update / crashes.
+      // Without this, a restart between "HERALD proposes" and user's "Procedi"
+      // routes the confirmation to a random agent (FORGE in the reported bug).
+      this._persistContext();
 
       await this._telegramCall('sendMessage', {
         chat_id: chatId,

package/src/services/tool-executor.mjs

@@ -163,8 +163,18 @@ TOOLS:
 14. calendar_create(summary: string, start: string, end: string, attendees?: string[], description?: string)
     Create a NEW calendar event. start/end are ISO 8601 datetime strings.
     Use this when the user says: "inserisci", "aggiungi", "crea", "metti", "fissa", "prenota", "add", "create", "schedule", "book".
+
+    PARAMETER MEANING (CRITICAL — most common mistake):
+      - summary  = the TITLE of the event (what you'd write on a calendar grid). Short, like "Tagliando BMW", "Riunione Cliente X", "Cena con Marta".
+      - description = optional NOTES/details. Leave empty unless the user gave extra context that doesn't fit in the title.
+      - NEVER put the title in description. NEVER leave summary empty.
+
+    Example — user says "fissa tagliando BMW per il 15 maggio alle 17":
+      { "action": "calendar_create", "params": { "summary": "Tagliando BMW", "start": "2026-05-15T17:00:00", "end": "2026-05-15T18:00:00" } }
+
     IMPORTANT: When user says "inserisci appuntamento" or "crea evento" → use calendar_create, NOT calendar_find.
     Extract the summary, date, and time from the user message. If end time is not specified, default to 1 hour after start.
+    The tool RESPONSE will include "(eventId: ABC123)" — REMEMBER this ID. If the user later says "correggi", "modifica", "cambia", "sposta", "elimina" referring to this same event, use calendar_update / calendar_move / calendar_delete with that exact eventId — do NOT create a second event.
 
 15. calendar_move(eventId: string, newStart: string, newEnd: string)
     Reschedule an event. ALWAYS confirm before moving.
@@ -178,7 +188,16 @@ TOOLS:
 
 18. calendar_update(eventId: string, summary?: string, location?: string, description?: string, start?: string, end?: string)
     Update ANY field of an existing calendar event: title, location, description, start time, end time.
-    You MUST call calendar_find first to get the eventId. Only include fields that need to change. ALWAYS confirm before updating.
+    Only include fields that need to change.
+
+    HOW TO GET eventId — IN ORDER OF PREFERENCE:
+      1. From your OWN previous tool response in this conversation: when you ran calendar_create earlier, the response said "Event \"X\" created ... (eventId: ABC123)". Use that ABC123 directly. Do NOT search again.
+      2. If step 1 doesn't apply (event was created before this conversation), call calendar_find FIRST to look it up.
+
+    CRITICAL — "CORREGGI" / "MODIFICA" / "CAMBIA TITOLO" mappings:
+      When the user says "correggi", "modifica", "cambia", "rinomina", "sposta", "aggiorna" referring to the most recent event you just created, you MUST use calendar_update with the eventId from step 1 above.
+      Do NOT call calendar_create a second time — that would create a DUPLICATE event.
+      Example: you just created event ABC123 ("Visita BMW"). User says "correggi, il titolo è Tagliando BMW" → call calendar_update(eventId: "ABC123", summary: "Tagliando BMW"). Don't create a new event, don't delete-then-create.
 
 19. calendar_delete(eventId: string)
     Delete (permanently remove) a calendar event by its eventId.
@@ -657,29 +676,95 @@ When the user's request requires an action, output one or more fenced JSON block
 \`\`\`
 Multiple blocks allowed for chaining. Include natural text before/between/after blocks.
 Never output a JSON block as a suggestion — every block executes immediately.
-FINANCE: For financial analysis — ALWAYS call real data tools first (market_price → market_chart → market_indicators OR crypto_data + macro_data), then canvas_render with a full Chart.js HTML dashboard (dark theme: bg #070b0f, green #00ff41, amber #f59e0b, red #ff4444, blue #00e5ff). Never invent prices.
-
-AVAILABLE TOOLS:
-gmail_list · gmail_read · gmail_send · gmail_draft · gmail_reply · gmail_mark_read · gmail_mark_unread · gmail_archive · gmail_delete · gmail_send_attach
-imap_accounts · imap_list · imap_read · imap_send · imap_sync · imap_labels · imap_mark_read · imap_reply · imap_thread · imap_search · imap_mark_starred · imap_trash · imap_draft · imap_send_template · imap_bulk_send
-calendar_today · calendar_tomorrow · calendar_date · calendar_upcoming · calendar_week · calendar_month · calendar_create · calendar_move · calendar_find · calendar_update · calendar_delete · schedule_meeting · schedule_draft_email
-task_list · task_add · task_done · task_move · task_delete · task_clear · task_edit
-contact_search · contact_add · contact_update · contact_delete
-gtask_list · gtask_add · gtask_complete
-note_add · note_list
-github_issues · github_prs · github_notifications · github_create_issue
-notion_search · notion_page
-slack_channels · slack_messages · slack_send
-web_search · fetch_url · get_weather
-browser_open · browser_screenshot · browser_click · browser_type · browser_extract · browser_js · browser_wait · browser_scroll · browser_key · browser_close
-cron_add · cron_list · cron_remove
-screen_capture · screen_analyze
-canvas_render · canvas_clear
-collab_send · collab_read
-file_list · file_read · file_write · file_info · file_search
-drive_list · drive_read · drive_upload · drive_update · drive_delete · drive_info · drive_folder · drive_download
-maps_directions · notify_remind · birthdays_upcoming · birthday_add · execute_code
-market_price · market_chart · market_indicators · macro_data · crypto_data · market_news`.trim();
+
+## ABSOLUTE RULES (violate these and the user loses trust)
+
+1. NEVER invent tool output. If you need data (an event ID, a price, a search result), you MUST emit a tool JSON block and wait for its real response. Do NOT write fake "(eventId: 123456789)" or fake results.
+2. NEVER duplicate. If the user says "correggi/modifica/sposta/aggiorna" referring to an item you just created in this conversation, use the corresponding *_update / *_move tool with the eventId/taskId from your previous tool response. Do NOT create a second item.
+3. NEVER put the TITLE in the description field. The "summary" / "title" field is the SHORT name (what shows on a calendar grid). The "description" field is ONLY for extra notes.
+4. When in doubt, ASK ONE concise question — do not invent details.
+
+## TOOL SIGNATURES (parameters and how to use them)
+
+### Calendar
+calendar_create(summary, start, end, description?, attendees?, location?)
+  - summary = SHORT title (e.g. "Tagliando BMW"). REQUIRED. Do NOT leave empty.
+  - description = optional notes only. Do NOT put the title here.
+  - start/end = ISO 8601 datetimes. Default end = start + 1 hour.
+  - The tool response includes "(eventId: ABC123)" — REMEMBER it for later updates.
+  Example — user: "fissa tagliando BMW 15 maggio ore 17":
+    {"action":"calendar_create","params":{"summary":"Tagliando BMW","start":"2026-05-15T17:00:00","end":"2026-05-15T18:00:00"}}
+
+calendar_update(eventId, summary?, location?, description?, start?, end?)
+  - Use this for "correggi", "modifica", "rinomina", "cambia titolo", "sposta", "aggiorna" referring to an event you JUST created or found.
+  - eventId comes from the previous calendar_create response or calendar_find result. NEVER guess it.
+  - Example — you just created event ABC123. User: "correggi, il titolo è Tagliando BMW":
+    {"action":"calendar_update","params":{"eventId":"ABC123","summary":"Tagliando BMW"}}
+
+calendar_delete(eventId)  — Delete an event you have the eventId for. Confirm first.
+calendar_move(eventId, newStart, newEnd)  — Reschedule.
+calendar_find(query, daysAhead?)  — Search events by name. Returns eventIds. Use ONLY when you don't already have the id.
+calendar_today() / calendar_tomorrow() / calendar_date(date) / calendar_upcoming(hours?) / calendar_week(startDate?) / calendar_month(month?)  — Read-only listings.
+schedule_meeting(clientName, subject, location, durationMinutes, dateFrom, dateTo)  — Find optimal slots considering travel time.
+
+### Gmail / IMAP
+gmail_list(limit?, query?)  — List recent emails. query supports Gmail search syntax.
+gmail_read(messageId)  — Read full email body.
+gmail_send(to, subject, body, cc?, bcc?)  — Send a new email.
+gmail_reply(messageId, body)  — Reply to a thread.
+gmail_draft(to, subject, body)  — Save a draft without sending.
+gmail_mark_read(messageId) / gmail_mark_unread(messageId) / gmail_archive(messageId) / gmail_delete(messageId)
+gmail_send_attach(to, subject, body, filePath)  — Send with attachment.
+imap_*  — Same operations for non-Gmail accounts. imap_send_template/imap_bulk_send for templated sends.
+
+### Tasks
+task_list() / task_add(text, dueDate?) / task_done(index) / task_edit(index, newText) / task_move(fromIndex, toIndex) / task_delete(index) / task_clear()
+gtask_list() / gtask_add(text) / gtask_complete(taskId)  — Google Tasks.
+
+### Contacts
+contact_search(query) / contact_add(name, email?, phone?) / contact_update(id, fields) / contact_delete(id)
+
+### Web + research
+web_search(query)  — Search the web (returns title/URL/snippet for top results).
+fetch_url(url)  — Fetch a page; returns title, meta description, OG tags, JSON-LD, main content. Use the full URL with https://. For naked domains (www.x.com), prepend https://.
+get_weather(location)  — Returns current conditions + 3-day forecast.
+maps_directions(origin, destination)
+
+### Browser automation (for JS-rendered pages or interaction)
+browser_open(url) → returns sessionId. browser_screenshot(sessionId) · browser_click(sessionId, selector) · browser_type(sessionId, selector, text) · browser_extract(sessionId, selector) · browser_js(sessionId, code) · browser_wait(sessionId, ms) · browser_scroll(sessionId, deltaY) · browser_key(sessionId, key) · browser_close(sessionId)
+
+### Notes / GitHub / Notion / Slack
+note_add(text) · note_list()
+github_issues(repo) · github_prs(repo) · github_notifications() · github_create_issue(repo, title, body)
+notion_search(query) · notion_page(pageId)
+slack_channels() · slack_messages(channel) · slack_send(channel, text)
+
+### Files / Drive
+file_list(dir?) · file_read(path) · file_write(path, content) · file_info(path) · file_search(query)
+drive_list(folderId?) · drive_read(fileId) · drive_upload(name, content, folderId?) · drive_update(fileId, content) · drive_delete(fileId) · drive_info(fileId) · drive_folder(name, parentId?) · drive_download(fileId, savePath)
+
+### Reminders / automation
+notify_remind(text, when)  — Notify the user at a future time.
+birthdays_upcoming(days?) · birthday_add(name, date)
+cron_add(schedule, prompt) · cron_list() · cron_remove(index)
+
+### Screen / canvas / collab
+screen_capture() / screen_analyze(question?)
+canvas_render(html, title?)  — Render an HTML report/dashboard in the canvas panel.
+collab_send(channel, text) · collab_read(channel)
+
+### Finance
+market_price(symbol) · market_chart(symbol, period?) · market_indicators(symbol) · macro_data(metric, country?) · crypto_data(coin) · market_news(symbol?)
+FINANCE FLOW: always call real data tools first (market_price → market_chart → market_indicators OR crypto_data + macro_data), then canvas_render with a Chart.js HTML dashboard (dark theme: bg #070b0f, green #00ff41, amber #f59e0b, red #ff4444, blue #00e5ff). Never invent prices.
+
+### Code
+execute_code(language, code)  — Run Python/JS/shell in a sandbox.
+
+## CONFIRMATIONS
+
+Write operations that change state (gmail_send/reply/delete, calendar_create/update/move/delete, contact_delete, task_done/delete, notify_remind, file_write, drive_upload/update/delete) — describe what you're about to do in natural language first, then emit the JSON block. The system shows the user what's pending and acts on confirmation.
+
+If the user already confirmed in the previous turn ("procedi", "sì", "fallo"), execute the pending action directly using the parameters from that prior turn — do NOT ask again or restart from scratch.`.trim();
 
 // ── Action Parser ────────────────────────────────────────────────────────────
 
@@ -1309,14 +1394,43 @@ export async function executeTool(action, params, config) {
     }
 
     case 'calendar_create': {
-      await createEvent(config, {
-        summary: params.summary,
+      // Robustness: accept common param-name aliases that the model often
+      // emits instead of `summary` (Google Calendar's official field name
+      // for the event title — but LLMs trained on natural language confuse
+      // "summary" with "description/note", so they sometimes put the actual
+      // title under `title`/`name`/`subject` or even leave summary empty
+      // and put the title text in `description`).
+      let summary = params.summary || params.title || params.name || params.subject || '';
+      let description = params.description || params.notes || '';
+
+      // Last-resort fallback: if summary is still empty but description
+      // looks like a title (one line, < 120 chars, no period), promote it.
+      if (!summary.trim() && description.trim()) {
+        const firstLine = description.split('\n')[0].trim();
+        if (firstLine.length > 0 && firstLine.length < 120) {
+          summary = firstLine;
+          // If description was JUST the title, clear it — otherwise keep the rest
+          const rest = description.split('\n').slice(1).join('\n').trim();
+          description = rest;
+        }
+      }
+
+      if (!summary.trim()) {
+        return 'Error: event title (summary) is required. Please specify what the event is about.';
+      }
+
+      const created = await createEvent(config, {
+        summary,
         start: params.start,
         end: params.end,
-        description: params.description || '',
+        description,
         attendees: params.attendees || [],
       });
-      return `Event "${params.summary}" created for ${formatTime(params.start)} - ${formatTime(params.end)}.`;
+      // Surface the eventId so the model/Telegram responder can use it for
+      // subsequent calendar_update or calendar_delete in the same turn.
+      const eventId = created?.id || created?.eventId || '';
+      const idHint = eventId ? ` (eventId: ${eventId})` : '';
+      return `Event "${summary}" created for ${formatTime(params.start)} - ${formatTime(params.end)}.${idHint}`;
     }
 
     case 'calendar_move': {
@@ -1432,10 +1546,15 @@ export async function executeTool(action, params, config) {
         }
       }
 
+      // Accept same param-name aliases as calendar_create so the model can
+      // be sloppy about title vs summary without breaking things.
+      const newSummary = params.summary || params.title || params.name || params.subject;
+      const newDescription = params.description ?? params.notes;
+
       const patch = {};
-      if (params.summary) patch.summary = params.summary;
+      if (newSummary) patch.summary = newSummary;
       if (params.location) patch.location = params.location;
-      if (params.description) patch.description = params.description;
+      if (newDescription !== undefined) patch.description = newDescription;
       if (params.start) {
         const tz = Intl.DateTimeFormat().resolvedOptions().timeZone;
         patch.start = { dateTime: new Date(params.start).toISOString(), timeZone: tz };
@@ -1444,9 +1563,12 @@ export async function executeTool(action, params, config) {
         const tz = Intl.DateTimeFormat().resolvedOptions().timeZone;
         patch.end = { dateTime: new Date(params.end).toISOString(), timeZone: tz };
       }
+      if (Object.keys(patch).length === 0) {
+        return 'No fields to update. Specify at least one of: summary (title), location, description, start, end.';
+      }
       await updateEvent(config, 'primary', eventId, patch);
       const changes = Object.keys(patch).join(', ');
-      return `Event updated successfully (${changes}). ${params.location ? `New location: ${params.location}` : ''}`;
+      return `Event updated successfully (changed: ${changes})${newSummary ? `. New title: "${newSummary}"` : ''}${params.location ? `. New location: ${params.location}` : ''}`;
     }
 
     case 'calendar_delete': {