nothumanallowed 15.1.9 → 15.1.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nothumanallowed",
-  "version": "15.1.9",
+  "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/commands/ui.mjs

@@ -84,11 +84,42 @@ export async function cmdUI(args) {
     }
   } catch { /* port is free */ }
 
-  // Auto-start ops daemon (Telegram + cron) if not already running
+  // Detect if we were spawned by the self-restart helper after an npm-update.
+  // The marker file is written by /api/npm-update right before exiting.
+  // This lets us:
+  //   - confirm to the user that the upgrade landed (visible in the boot log)
+  //   - guarantee the ops daemon (Telegram/Discord bot) is back up
+  let restartedFromUpdate = false;
+  try {
+    const fs = await import('fs');
+    const path = await import('path');
+    const os = await import('os');
+    const markerPath = path.join(os.default.homedir(), '.nha', 'last-restart.json');
+    if (fs.existsSync(markerPath)) {
+      const stat = fs.statSync(markerPath);
+      // Consider the marker fresh only if written within the last 5 minutes
+      if (Date.now() - stat.mtimeMs < 5 * 60_000) {
+        const meta = JSON.parse(fs.readFileSync(markerPath, 'utf-8'));
+        restartedFromUpdate = true;
+        console.log(`  \x1b[0;32m↻\x1b[0m Restarted after update: v${meta.fromVersion} → v${meta.toVersion}`);
+      }
+      // Always clean up so we don't repeat the message on next manual restart
+      try { fs.unlinkSync(markerPath); } catch {}
+    }
+  } catch { /* non-fatal */ }
+
+  // Auto-start ops daemon (Telegram + cron) if not already running.
+  // After a self-restart this is what brings the Telegram bot back online —
+  // critical for VM users whose only control channel is Telegram.
   if (!isRunning()) {
     const result = startDaemon();
     if (result.ok) {
-      console.log(`  \x1b[0;32m✓\x1b[0m PAO daemon started (PID ${result.pid})`);
+      console.log(`  \x1b[0;32m✓\x1b[0m PAO daemon ${restartedFromUpdate ? 'restarted' : 'started'} (PID ${result.pid})`);
+    } else {
+      console.log(`  \x1b[0;31m✗\x1b[0m PAO daemon failed to start: ${result.error || 'unknown'}`);
+      if (restartedFromUpdate) {
+        console.log(`    Telegram/Discord bot may be offline. Run "nha ops start" manually.`);
+      }
     }
   }
 

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.9';
+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/server/index.mjs

@@ -376,15 +376,40 @@ export async function startServer({ port = 3847, host = '127.0.0.1', noBrowser =
 
   const server = http.createServer(handleRequest);
 
-  // Attach WebSocket AFTER HTTP server is listening to avoid WS error events
-  await new Promise((resolve, reject) => {
-    server.once('error', reject);
+  // Retry the bind for up to 12 s on EADDRINUSE. The classic case is a fresh
+  // self-restart right after the previous process died: the listen socket can
+  // be stuck in TIME_WAIT (no PID owns it, so the lsof-kill above can't help).
+  // Linear backoff 600 ms × 20 = 12 s — more than enough on every kernel I've
+  // seen for a localhost listen socket to clear.
+  const tryListen = () => new Promise((resolve, reject) => {
+    const onErr = (err) => reject(err);
+    server.once('error', onErr);
     server.listen(port, host, () => {
-      server.removeListener('error', reject);
+      server.removeListener('error', onErr);
       resolve(undefined);
     });
   });
 
+  let listenAttempts = 0;
+  const MAX_LISTEN_ATTEMPTS = 20;
+  while (true) {
+    try {
+      await tryListen();
+      break;
+    } catch (err) {
+      listenAttempts++;
+      const isAddrInUse = err && (err.code === 'EADDRINUSE' || err.code === 'EACCES');
+      if (!isAddrInUse || listenAttempts >= MAX_LISTEN_ATTEMPTS) {
+        throw err;
+      }
+      // Brief notice every 3 s so the user knows we're not stuck
+      if (listenAttempts % 5 === 0) {
+        console.log(`\x1b[33m  ! Port ${port} still busy (TIME_WAIT?), retry ${listenAttempts}/${MAX_LISTEN_ATTEMPTS}...\x1b[0m`);
+      }
+      await new Promise((r) => setTimeout(r, 600));
+    }
+  }
+
   setupWebSocket(server);
 
   const G = '\x1b[0;32m', NC = '\x1b[0m', D = '\x1b[2m', BOLD = '\x1b[1m', Y = '\x1b[33m', R = '\x1b[31m';

package/src/server/routes/config.mjs

@@ -146,10 +146,17 @@ export function register(router) {
         }
       } catch { /* ignore */ }
 
-      // Stop the ops daemon if it's running — it must reconnect with new code
+      // Remember if the ops daemon (Telegram/Discord bot) was running so the
+      // newly-spawned server can restart it. Without this, a VM user who
+      // controls everything via Telegram would lose the bot until they ran
+      // `nha ops start` manually.
+      let daemonWasRunning = false;
       try {
         const { isRunning, stopDaemon } = await import('../../services/ops-daemon.mjs');
-        if (isRunning()) await stopDaemon();
+        if (isRunning()) {
+          daemonWasRunning = true;
+          await stopDaemon();
+        }
       } catch { /* ignore */ }
 
       // Send the response NOW, before we kick off the restart. The client
@@ -166,62 +173,87 @@ export function register(router) {
       });
 
       // ── Schedule the self-restart ──
-      // We do this OUTSIDE the response cycle: a detached child that survives
-      // our death, watches our PID, then re-spawns with the same argv.
-      // On POSIX we use `sh -c`. On Windows we use a detached spawn directly
-      // because cmd.exe handles the "wait for PID" idiom differently.
       const parentPid = process.pid;
-      const respawnNode = process.execPath;             // absolute path to node
-      const respawnArgs = process.argv.slice(1);        // [cli.mjs, "ui", ...]
-      const argvJson = JSON.stringify({ node: respawnNode, args: respawnArgs, parentPid });
+      const respawnNode = process.execPath;
+      const respawnArgs = process.argv.slice(1);
+      const home = os.homedir();
+      const nhaDir = path.join(home, '.nha');
+      if (!fs.existsSync(nhaDir)) fs.mkdirSync(nhaDir, { recursive: true });
+
+      // Write the restart marker BEFORE spawning the helper. The new server
+      // reads this on boot to know:
+      //   - the update happened (so it can show "Updated to v…" on first load)
+      //   - whether the ops daemon (Telegram bot) was running and must be restarted
+      const markerPath = path.join(nhaDir, 'last-restart.json');
+      try {
+        fs.writeFileSync(
+          markerPath,
+          JSON.stringify({
+            at: new Date().toISOString(),
+            fromVersion: VERSION,
+            toVersion: newVersion,
+            daemonWasRunning,
+            parentPid,
+          }, null, 2),
+        );
+      } catch { /* non-fatal */ }
+
+      // Open log file for the detached child — if anything goes wrong on boot
+      // we want the user to be able to read why instead of staring at a black
+      // screen. Append mode so previous restart logs survive.
+      const logPath = path.join(nhaDir, 'server.log');
+      let logFd;
+      try {
+        logFd = fs.openSync(logPath, 'a');
+        fs.writeSync(logFd, `\n[${new Date().toISOString()}] === Restart helper spawning. Parent PID: ${parentPid}. Target version: ${newVersion} ===\n`);
+      } catch { /* will fall back to 'ignore' */ }
 
       setTimeout(() => {
         try {
           if (process.platform === 'win32') {
-            // Windows: schedule via PowerShell — wait-process then start the new node.
-            const psScript = `
-              try { Wait-Process -Id ${parentPid} -Timeout 30 } catch {};
-              Start-Sleep -Milliseconds 1200;
-              Start-Process -FilePath "${respawnNode.replace(/\\/g, '\\\\')}" -ArgumentList ${JSON.stringify(respawnArgs).replace(/"/g, '\\"')} -WindowStyle Hidden
-            `.replace(/\s+/g, ' ').trim();
+            // Windows: PowerShell waits for the parent to die, frees the port,
+            // then starts node hidden. Output is redirected to server.log.
+            const psScript = [
+              `try { Wait-Process -Id ${parentPid} -Timeout 30 } catch {};`,
+              `Start-Sleep -Milliseconds 1500;`,
+              `$logPath = "${logPath.replace(/\\/g, '\\\\')}";`,
+              `Start-Process -FilePath "${respawnNode.replace(/\\/g, '\\\\')}"`,
+              ` -ArgumentList ${JSON.stringify(respawnArgs).replace(/"/g, '\\"')}`,
+              ` -RedirectStandardOutput $logPath -RedirectStandardError $logPath`,
+              ` -WindowStyle Hidden`,
+            ].join('').replace(/\s+/g, ' ').trim();
             spawn('powershell.exe', ['-NoProfile', '-Command', psScript], {
               detached: true,
               stdio: 'ignore',
               windowsHide: true,
             }).unref();
           } else {
-            // POSIX: shell loop that polls `kill -0 PID`, then re-exec the cmd.
-            // Using exec replaces the shell process so we don't leave a wrapper.
-            const escapedArgs = respawnArgs.map(a => `'${a.replace(/'/g, `'\\''`)}'`).join(' ');
-            const escapedNode = `'${respawnNode.replace(/'/g, `'\\''`)}'`;
+            // POSIX: poll for parent death (max ~12s), then wait an extra 2s
+            // for TIME_WAIT to clear on the listen socket, then exec node
+            // with stdio redirected to the log file.
+            const escArg = a => `'${a.replace(/'/g, `'\\''`)}'`;
+            const escapedArgs = respawnArgs.map(escArg).join(' ');
+            const escapedNode = escArg(respawnNode);
+            const escapedLog = escArg(logPath);
             const sh = `
               i=0
               while kill -0 ${parentPid} 2>/dev/null && [ $i -lt 60 ]; do
                 sleep 0.2
                 i=$((i+1))
               done
-              sleep 1
-              exec ${escapedNode} ${escapedArgs}
+              # Extra wait: lets TIME_WAIT on the listen socket release and
+              # gives the kernel a moment to fully reap the parent.
+              sleep 2
+              exec ${escapedNode} ${escapedArgs} >> ${escapedLog} 2>&1
             `;
+            const childStdio = logFd ? ['ignore', logFd, logFd] : 'ignore';
             spawn('sh', ['-c', sh], {
               detached: true,
-              stdio: 'ignore',
+              stdio: childStdio,
             }).unref();
           }
-
-          // Mark the restart so the next process knows it was self-spawned
-          try {
-            const home = os.homedir();
-            const nhaDir = path.join(home, '.nha');
-            if (!fs.existsSync(nhaDir)) fs.mkdirSync(nhaDir, { recursive: true });
-            fs.writeFileSync(
-              path.join(nhaDir, 'last-restart.json'),
-              JSON.stringify({ at: new Date().toISOString(), fromVersion: VERSION, toVersion: newVersion, meta: argvJson }, null, 2),
-            );
-          } catch { /* non-fatal */ }
         } catch { /* spawn failed — user will need to restart manually */ }
 
-        // Give the response a moment, then exit so the helper can take over.
         setTimeout(() => process.exit(0), 200);
       }, 600);
     } catch (e) {

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': {