nothumanallowed 2.0.0 → 2.1.0

package/README.md

@@ -20,6 +20,46 @@ nha ask oracle "Analyze this dataset" --file data.csv
 nha run "Design a Kubernetes deployment for a 10K RPS API"
 ```
 
+## Daily Operations (PAO)
+
+Connect Gmail + Calendar. 5 specialist agents analyze your day.
+
+```bash
+# Connect Google (one-time)
+nha config set google-client-id YOUR_ID
+nha config set google-client-secret YOUR_SECRET
+nha google auth
+
+# Generate your daily plan
+nha plan
+
+# Manage tasks
+nha tasks add "Review PR #42" --priority high
+nha tasks done 1
+nha tasks week
+
+# Background daemon (auto-alerts before meetings, email security scans)
+nha ops start
+```
+
+**What `nha plan` does:**
+1. **Fetches** your emails + calendar events + tasks
+2. **SABER** scans emails for phishing and security threats
+3. **HERALD** generates intelligence briefs for each meeting
+4. **ORACLE** analyzes schedule patterns and productivity
+5. **SCHEHERAZADE** prepares talking points for meetings
+6. **CONDUCTOR** synthesizes everything into a structured daily plan
+
+OpenClaw reads your email with 1 generic agent. NHA sends it through 5 specialists.
+
+### Privacy
+
+**Zero data touches NHA servers.** The only network calls are:
+- Google APIs (your OAuth token, direct from your machine)
+- Your LLM provider (your API key, direct from your machine)
+
+All data stored locally in `~/.nha/ops/`. Tokens encrypted with AES-256-GCM. You own everything. Inspect it, delete it, export it anytime.
+
 ## The Agents
 
 38 agents across 11 domains. Each agent is a standalone `.mjs` file you own locally — inspect it, modify it, run it offline.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nothumanallowed",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "NotHumanAllowed — 38 AI agents for security, code, DevOps, data & daily ops. Ask agents directly, plan your day with 5 specialist agents, manage tasks, connect Gmail + Calendar.",
   "type": "module",
   "bin": {

package/src/cli.mjs

@@ -12,6 +12,7 @@ import { cmdAsk } from './commands/ask.mjs';
 import { cmdPlan } from './commands/plan.mjs';
 import { cmdTasks } from './commands/tasks.mjs';
 import { cmdOps } from './commands/ops.mjs';
+import { cmdChat } from './commands/chat.mjs';
 import { cmdGoogle } from './commands/google-auth.mjs';
 import { banner, info, ok, warn, fail, C, G, Y, D, W, BOLD, NC, M, B, R } from './ui.mjs';
 
@@ -54,6 +55,9 @@ export async function main(argv) {
     case 'ops':
       return cmdOps(args);
 
+    case 'chat':
+      return cmdChat(args);
+
     case 'google':
       return cmdGoogle(args);
 
@@ -351,6 +355,7 @@ function cmdHelp() {
   console.log(`    run "prompt" ${D}--agents saber,zero${NC}   Collaborate with specific agents\n`);
 
   console.log(`  ${C}Daily Operations${NC}  ${D}(Gmail + Calendar + Tasks)${NC}`);
+  console.log(`    chat                  Interactive chat — manage email/calendar/tasks naturally`);
   console.log(`    plan                  Generate daily plan (5 agents analyze your day)`);
   console.log(`    plan --refresh        Regenerate today's plan`);
   console.log(`    tasks                 List today's tasks`);

package/src/commands/chat.mjs

@@ -0,0 +1,730 @@
+/**
+ * nha chat — Interactive conversational REPL for PAO (Personal Agent Ops).
+ *
+ * The user types natural language; an LLM interprets intent, optionally
+ * invokes Gmail / Calendar / Tasks APIs via a structured JSON action protocol,
+ * and responds conversationally.
+ *
+ * Zero npm dependencies — Node.js 22 built-in readline only.
+ */
+
+import readline from 'readline';
+import { loadConfig } from '../config.mjs';
+import { callLLM } from '../services/llm.mjs';
+import { fail, info, ok, warn, C, G, Y, D, W, BOLD, NC, M, R, B } from '../ui.mjs';
+
+// ── Gmail imports ────────────────────────────────────────────────────────────
+import {
+  listMessages,
+  getMessage,
+  getUnreadImportant,
+  sendEmail,
+  createDraft,
+} from '../services/google-gmail.mjs';
+
+// ── Calendar imports ─────────────────────────────────────────────────────────
+import {
+  getTodayEvents,
+  getUpcomingEvents,
+  getEventsForDate,
+  createEvent,
+  updateEvent,
+} from '../services/google-calendar.mjs';
+
+// ── Task imports ─────────────────────────────────────────────────────────────
+import {
+  getTasks,
+  addTask,
+  completeTask,
+  moveTask,
+} from '../services/task-store.mjs';
+
+// ── Notification imports ─────────────────────────────────────────────────────
+import { notify } from '../services/notification.mjs';
+
+// ── Constants ────────────────────────────────────────────────────────────────
+
+const MAX_HISTORY = 20;
+
+/** Actions that mutate external state and require user confirmation. */
+const DESTRUCTIVE_ACTIONS = new Set([
+  'gmail_send',
+  'gmail_reply',
+  'calendar_create',
+  'calendar_move',
+  'task_done',
+  'notify_remind',
+]);
+
+// ── Tool Definitions (for system prompt) ─────────────────────────────────────
+
+const TOOL_DEFINITIONS = `
+You have access to the following tools. When the user's message requires an action,
+output EXACTLY ONE fenced JSON block per action:
+
+\`\`\`json
+{"action": "<tool_name>", "params": { ... }}
+\`\`\`
+
+You may include conversational text BEFORE or AFTER the JSON block. If no action
+is needed, respond normally without any JSON block.
+
+TOOLS:
+
+1. gmail_list(query: string, maxResults?: number)
+   Search emails. query uses Gmail search syntax (e.g. "from:boss@co.com", "is:unread subject:invoice").
+   Default maxResults = 10.
+
+2. gmail_read(messageId: string)
+   Read the full body of an email by its ID (returned by gmail_list).
+
+3. gmail_send(to: string, subject: string, body: string)
+   Send an email. ALWAYS confirm with the user before sending.
+
+4. gmail_draft(to: string, subject: string, body: string)
+   Create a draft email (safe — does not send).
+
+5. gmail_reply(messageId: string, body: string)
+   Reply to an existing email thread. ALWAYS confirm before sending.
+
+6. calendar_today()
+   List all events for today.
+
+7. calendar_tomorrow()
+   List all events for tomorrow.
+
+8. calendar_upcoming(hours?: number)
+   List upcoming events in the next N hours (default 2).
+
+9. calendar_create(summary: string, start: string, end: string, attendees?: string[], description?: string)
+   Create a calendar event. start/end are ISO 8601 datetime strings.
+   ALWAYS confirm with the user before creating.
+
+10. calendar_move(eventId: string, newStart: string, newEnd: string)
+    Reschedule an event. ALWAYS confirm before moving.
+
+11. task_list()
+    List today's tasks.
+
+12. task_add(description: string, priority?: "low"|"medium"|"high"|"critical", due?: string)
+    Add a new task for today.
+
+13. task_done(id: number)
+    Mark a task as completed. Confirm before completing.
+
+14. task_move(id: number, toDate: string)
+    Move a task to another date (YYYY-MM-DD).
+
+15. notify_remind(message: string, atTime: string)
+    Set a desktop reminder. atTime is ISO 8601 or relative like "in 30 minutes".
+
+RULES:
+- For search/read operations, execute immediately and present results conversationally.
+- For write/send/delete operations (gmail_send, gmail_reply, calendar_create, calendar_move, task_done, notify_remind), DESCRIBE what you're about to do and include the JSON block so the system can ask the user for confirmation.
+- When presenting email results, show From, Subject, Date, and a brief snippet. Never dump raw JSON.
+- When presenting calendar events, show Time, Title, Location/Link. Format times in a human-readable way.
+- When presenting tasks, show ID, Description, Priority, Status.
+- If you need multiple actions in sequence (e.g., read an email then reply), do them ONE AT A TIME — wait for the result of each before proceeding.
+- Dates: today is {{TODAY}}. Infer relative dates from this.
+- The user's timezone is {{TIMEZONE}}.
+`.trim();
+
+// ── Tool Executor ────────────────────────────────────────────────────────────
+
+/**
+ * Execute a parsed tool action and return a human-readable result string.
+ * @param {string} action — tool name
+ * @param {object} params — tool parameters
+ * @param {object} config — NHA config
+ * @returns {Promise<string>} result description
+ */
+async function executeTool(action, params, config) {
+  switch (action) {
+    // ── Gmail ──────────────────────────────────────────────────────────────
+    case 'gmail_list': {
+      const query = params.query || 'is:unread';
+      const max = params.maxResults || 10;
+      const refs = await listMessages(config, query, max);
+      if (refs.length === 0) return 'No emails found matching that query.';
+
+      const messages = [];
+      for (const ref of refs.slice(0, max)) {
+        try {
+          const msg = await getMessage(config, ref.id);
+          messages.push(msg);
+        } catch { /* skip failed */ }
+      }
+
+      return messages.map((m, i) =>
+        `${i + 1}. [${m.id}] From: ${m.from} | Subject: ${m.subject} | Date: ${m.date}\n   ${m.snippet.slice(0, 120)}`
+      ).join('\n');
+    }
+
+    case 'gmail_read': {
+      const msg = await getMessage(config, params.messageId);
+      return [
+        `From: ${msg.from}`,
+        `To: ${msg.to}`,
+        `Subject: ${msg.subject}`,
+        `Date: ${msg.date}`,
+        `---`,
+        msg.body.slice(0, 4000),
+      ].join('\n');
+    }
+
+    case 'gmail_send': {
+      await sendEmail(config, params.to, params.subject, params.body);
+      return `Email sent to ${params.to} with subject "${params.subject}".`;
+    }
+
+    case 'gmail_draft': {
+      await createDraft(config, params.to, params.subject, params.body);
+      return `Draft created for ${params.to} with subject "${params.subject}".`;
+    }
+
+    case 'gmail_reply': {
+      const original = await getMessage(config, params.messageId);
+      await sendEmail(config, original.from, `Re: ${original.subject}`, params.body, {
+        replyToMessageId: original.id,
+        threadId: original.threadId,
+      });
+      return `Reply sent to ${original.from} on thread "${original.subject}".`;
+    }
+
+    // ── Calendar ──────────────────────────────────────────────────────────
+    case 'calendar_today': {
+      const events = await getTodayEvents(config);
+      if (events.length === 0) return 'No events scheduled for today.';
+      return formatEvents(events);
+    }
+
+    case 'calendar_tomorrow': {
+      const tomorrow = new Date();
+      tomorrow.setDate(tomorrow.getDate() + 1);
+      const dateStr = tomorrow.toISOString().split('T')[0];
+      const events = await getEventsForDate(config, dateStr);
+      if (events.length === 0) return 'No events scheduled for tomorrow.';
+      return formatEvents(events);
+    }
+
+    case 'calendar_upcoming': {
+      const hours = params.hours || 2;
+      const events = await getUpcomingEvents(config, hours);
+      if (events.length === 0) return `No events in the next ${hours} hour(s).`;
+      return formatEvents(events);
+    }
+
+    case 'calendar_create': {
+      const result = await createEvent(config, {
+        summary: params.summary,
+        start: params.start,
+        end: params.end,
+        description: params.description || '',
+        attendees: params.attendees || [],
+      });
+      return `Event "${params.summary}" created for ${formatTime(params.start)} - ${formatTime(params.end)}.`;
+    }
+
+    case 'calendar_move': {
+      const tz = Intl.DateTimeFormat().resolvedOptions().timeZone;
+      await updateEvent(config, 'primary', params.eventId, {
+        start: { dateTime: new Date(params.newStart).toISOString(), timeZone: tz },
+        end: { dateTime: new Date(params.newEnd).toISOString(), timeZone: tz },
+      });
+      return `Event rescheduled to ${formatTime(params.newStart)} - ${formatTime(params.newEnd)}.`;
+    }
+
+    // ── Tasks ─────────────────────────────────────────────────────────────
+    case 'task_list': {
+      const tasks = getTasks();
+      if (tasks.length === 0) return 'No tasks for today.';
+      return tasks.map(t =>
+        `#${t.id} [${t.priority}] ${t.status === 'done' ? '[DONE] ' : ''}${t.description}${t.due ? ' (due: ' + t.due + ')' : ''}`
+      ).join('\n');
+    }
+
+    case 'task_add': {
+      const task = addTask({
+        description: params.description,
+        priority: params.priority || 'medium',
+        due: params.due || null,
+        source: 'chat',
+      });
+      return `Task #${task.id} added: "${task.description}" [${task.priority}]`;
+    }
+
+    case 'task_done': {
+      const success = completeTask(params.id);
+      return success ? `Task #${params.id} marked as done.` : `Task #${params.id} not found.`;
+    }
+
+    case 'task_move': {
+      const todayStr = new Date().toISOString().split('T')[0];
+      const success = moveTask(params.id, todayStr, params.toDate);
+      return success ? `Task #${params.id} moved to ${params.toDate}.` : `Task #${params.id} not found.`;
+    }
+
+    // ── Notifications ─────────────────────────────────────────────────────
+    case 'notify_remind': {
+      const atTime = resolveTime(params.atTime);
+      const delayMs = atTime.getTime() - Date.now();
+
+      if (delayMs <= 0) {
+        await notify('Reminder', params.message, config);
+        return `Reminder sent now: "${params.message}"`;
+      }
+
+      // Schedule in-process timer (will only persist while the REPL is running)
+      setTimeout(async () => {
+        try {
+          await notify('Reminder', params.message, config);
+        } catch { /* best effort */ }
+      }, Math.min(delayMs, 86400000)); // cap at 24h
+
+      const minutes = Math.round(delayMs / 60000);
+      return `Reminder set for ${formatTime(atTime.toISOString())} (in ~${minutes} min): "${params.message}"`;
+    }
+
+    default:
+      return `Unknown action: ${action}`;
+  }
+}
+
+// ── Formatting Helpers ───────────────────────────────────────────────────────
+
+function formatEvents(events) {
+  return events.map((e, i) => {
+    const time = e.isAllDay ? 'All day' : `${formatTime(e.start)} - ${formatTime(e.end)}`;
+    const location = e.location ? ` | ${e.location}` : '';
+    const link = e.hangoutLink ? ` | ${e.hangoutLink}` : '';
+    const cal = e.calendarName ? ` (${e.calendarName})` : '';
+    return `${i + 1}. ${time} — ${e.summary}${location}${link}${cal}`;
+  }).join('\n');
+}
+
+function formatTime(isoStr) {
+  try {
+    const d = new Date(isoStr);
+    return d.toLocaleTimeString('en-US', { hour: '2-digit', minute: '2-digit', hour12: true });
+  } catch {
+    return isoStr;
+  }
+}
+
+/**
+ * Resolve a time string into a Date. Supports ISO 8601 and relative formats
+ * like "in 30 minutes", "in 2 hours".
+ */
+function resolveTime(timeStr) {
+  // Try ISO parse first
+  const direct = new Date(timeStr);
+  if (!isNaN(direct.getTime()) && timeStr.includes('T')) return direct;
+
+  // Relative: "in X minutes/hours"
+  const relMatch = timeStr.match(/in\s+(\d+)\s+(minute|min|hour|hr)s?/i);
+  if (relMatch) {
+    const amount = parseInt(relMatch[1], 10);
+    const unit = relMatch[2].toLowerCase();
+    const ms = unit.startsWith('h') ? amount * 3600000 : amount * 60000;
+    return new Date(Date.now() + ms);
+  }
+
+  // Try time-only like "14:30" or "2:30 PM" — assume today
+  const today = new Date();
+  const timeOnly = new Date(`${today.toISOString().split('T')[0]}T${timeStr}`);
+  if (!isNaN(timeOnly.getTime())) return timeOnly;
+
+  // Fallback: now + 30 min
+  return new Date(Date.now() + 1800000);
+}
+
+// ── Action Parser ────────────────────────────────────────────────────────────
+
+/**
+ * Extract JSON action blocks from LLM response text.
+ * Supports ```json ... ``` fenced blocks.
+ * @param {string} text
+ * @returns {{ textParts: string[], actions: Array<{action: string, params: object}> }}
+ */
+function parseActions(text) {
+  const actions = [];
+  const textParts = [];
+  let remaining = text;
+
+  const fenceRegex = /```json\s*\n?([\s\S]*?)```/g;
+  let lastIndex = 0;
+  let match;
+
+  while ((match = fenceRegex.exec(remaining)) !== null) {
+    // Capture text before this block
+    const before = remaining.slice(lastIndex, match.index).trim();
+    if (before) textParts.push(before);
+
+    try {
+      const parsed = JSON.parse(match[1].trim());
+      if (parsed.action && typeof parsed.action === 'string') {
+        actions.push({ action: parsed.action, params: parsed.params || {} });
+      }
+    } catch {
+      // Not valid JSON — treat as regular text
+      textParts.push(match[0]);
+    }
+
+    lastIndex = match.index + match[0].length;
+  }
+
+  // Capture trailing text
+  const trailing = remaining.slice(lastIndex).trim();
+  if (trailing) textParts.push(trailing);
+
+  return { textParts, actions };
+}
+
+// ── System Prompt Builder ────────────────────────────────────────────────────
+
+function buildSystemPrompt(initialContext) {
+  const today = new Date().toISOString().split('T')[0];
+  const tz = Intl.DateTimeFormat().resolvedOptions().timeZone;
+
+  let prompt = TOOL_DEFINITIONS
+    .replace('{{TODAY}}', today)
+    .replace('{{TIMEZONE}}', tz);
+
+  prompt += `\n\nYou are NHA Chat, a personal operations assistant inside the NotHumanAllowed CLI. ` +
+    `You help the user manage their emails, calendar, and tasks through natural conversation. ` +
+    `Be concise, helpful, and proactive. When presenting data, format it clearly. ` +
+    `Never output raw JSON to the user — always wrap results in natural language.`;
+
+  if (initialContext) {
+    prompt += `\n\n--- CURRENT CONTEXT (fetched at session start) ---\n${initialContext}`;
+  }
+
+  return prompt;
+}
+
+/**
+ * Serialize conversation history into a single user message string.
+ * Each turn is prefixed with [User] or [Assistant] to maintain role clarity.
+ */
+function serializeHistory(history, currentMessage) {
+  const parts = [];
+
+  for (const turn of history) {
+    const prefix = turn.role === 'user' ? '[User]' : '[Assistant]';
+    parts.push(`${prefix} ${turn.content}`);
+  }
+
+  parts.push(`[User] ${currentMessage}`);
+  return parts.join('\n\n');
+}
+
+// ── Confirmation Prompt ──────────────────────────────────────────────────────
+
+/**
+ * Ask the user for y/n confirmation before executing a destructive action.
+ * @param {readline.Interface} rl
+ * @param {string} description
+ * @returns {Promise<boolean>}
+ */
+function askConfirmation(rl, description) {
+  return new Promise((resolve) => {
+    rl.question(`  ${Y}?${NC} ${description} ${D}[y/n]${NC} `, (answer) => {
+      resolve(answer.trim().toLowerCase() === 'y' || answer.trim().toLowerCase() === 'yes');
+    });
+  });
+}
+
+// ── Initial Context Fetcher ──────────────────────────────────────────────────
+
+async function fetchInitialContext(config) {
+  const parts = [];
+
+  // Today's events (best effort)
+  try {
+    const events = await getTodayEvents(config);
+    if (events.length > 0) {
+      parts.push(`TODAY'S CALENDAR (${events.length} events):\n` + formatEvents(events));
+    } else {
+      parts.push('TODAY\'S CALENDAR: No events scheduled.');
+    }
+  } catch {
+    parts.push('CALENDAR: Could not fetch (Google not connected?).');
+  }
+
+  // Unread emails (best effort)
+  try {
+    const emails = await getUnreadImportant(config, 10);
+    if (emails.length > 0) {
+      parts.push(`UNREAD EMAILS (${emails.length}):\n` +
+        emails.map((m, i) =>
+          `${i + 1}. [${m.id}] From: ${m.from} | Subject: ${m.subject}\n   ${m.snippet.slice(0, 100)}`
+        ).join('\n'));
+    } else {
+      parts.push('UNREAD EMAILS: Inbox zero!');
+    }
+  } catch {
+    parts.push('EMAIL: Could not fetch (Google not connected?).');
+  }
+
+  // Today's tasks
+  try {
+    const tasks = getTasks();
+    if (tasks.length > 0) {
+      parts.push(`TODAY'S TASKS (${tasks.length}):\n` +
+        tasks.map(t => `#${t.id} [${t.priority}] ${t.status === 'done' ? '[DONE] ' : ''}${t.description}`).join('\n'));
+    } else {
+      parts.push('TODAY\'S TASKS: None yet.');
+    }
+  } catch {
+    parts.push('TASKS: Could not load.');
+  }
+
+  return parts.join('\n\n');
+}
+
+// ── Slash Command Handlers ───────────────────────────────────────────────────
+
+/**
+ * Handle REPL-local slash commands. Returns true if handled, false to pass through.
+ */
+async function handleSlashCommand(input, config, history) {
+  const trimmed = input.trim();
+
+  if (trimmed === '/quit' || trimmed === '/exit' || trimmed === '/q') {
+    console.log(`\n  ${D}Session ended. Goodbye.${NC}\n`);
+    process.exit(0);
+  }
+
+  if (trimmed === '/clear') {
+    history.length = 0;
+    console.clear();
+    console.log(`  ${G}Conversation cleared.${NC}`);
+    return true;
+  }
+
+  if (trimmed === '/tasks') {
+    try {
+      const tasks = getTasks();
+      if (tasks.length === 0) {
+        console.log(`  ${D}No tasks for today.${NC}`);
+      } else {
+        for (const t of tasks) {
+          const icon = t.status === 'done' ? `${G}[done]${NC}` : `${Y}[${t.priority}]${NC}`;
+          console.log(`  ${icon} #${t.id} ${t.description}`);
+        }
+      }
+    } catch (err) {
+      console.log(`  ${R}Could not load tasks: ${err.message}${NC}`);
+    }
+    return true;
+  }
+
+  if (trimmed === '/plan') {
+    try {
+      const { cmdPlan } = await import('./plan.mjs');
+      await cmdPlan([]);
+    } catch (err) {
+      console.log(`  ${R}Plan error: ${err.message}${NC}`);
+    }
+    return true;
+  }
+
+  if (trimmed === '/help') {
+    console.log(`
+  ${BOLD}Chat Commands${NC}
+
+  ${C}/tasks${NC}    Show today's tasks
+  ${C}/plan${NC}     Run daily planner
+  ${C}/clear${NC}    Clear conversation history
+  ${C}/help${NC}     Show this help
+  ${C}/quit${NC}     Exit chat
+
+  ${D}Otherwise, just type naturally — the AI understands
+  requests like "show my unread emails", "add a task to review PR #42",
+  "what's on my calendar tomorrow?", etc.${NC}
+`);
+    return true;
+  }
+
+  return false;
+}
+
+// ── Main REPL ────────────────────────────────────────────────────────────────
+
+export async function cmdChat(args) {
+  const config = loadConfig();
+
+  if (!config.llm.apiKey) {
+    fail('No API key configured. Run: nha config set key YOUR_KEY');
+    process.exit(1);
+  }
+
+  // ── Greeting ────────────────────────────────────────────────────────────
+  console.log(`
+  ${BOLD}${C}NHA Chat${NC}  ${D}— Personal Operations Assistant${NC}
+  ${D}Type naturally to manage emails, calendar, and tasks.${NC}
+  ${D}Commands: /tasks /plan /clear /help /quit${NC}
+`);
+
+  // ── Fetch initial context (non-blocking display) ────────────────────────
+  info('Loading today\'s context...');
+  let initialContext = '';
+  try {
+    initialContext = await fetchInitialContext(config);
+    ok('Context loaded (calendar, email, tasks).');
+  } catch {
+    warn('Could not load full context. Google may not be connected.');
+    warn('Run "nha google auth" to connect Gmail + Calendar.');
+  }
+  console.log('');
+
+  // ── Readline setup ──────────────────────────────────────────────────────
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: `${C}NHA>${NC} `,
+    terminal: true,
+  });
+
+  const history = [];
+  const systemPrompt = buildSystemPrompt(initialContext);
+
+  // ── Graceful exit ───────────────────────────────────────────────────────
+  rl.on('close', () => {
+    console.log(`\n  ${D}Session ended. Goodbye.${NC}\n`);
+    process.exit(0);
+  });
+
+  // Handle SIGINT (Ctrl+C) gracefully — first press clears line, second exits
+  let pendingExit = false;
+  process.on('SIGINT', () => {
+    if (pendingExit) {
+      console.log(`\n  ${D}Goodbye.${NC}\n`);
+      process.exit(0);
+    }
+    pendingExit = true;
+    console.log(`\n  ${D}Press Ctrl+C again to exit, or type to continue.${NC}`);
+    rl.prompt();
+    setTimeout(() => { pendingExit = false; }, 3000);
+  });
+
+  // ── REPL Loop ───────────────────────────────────────────────────────────
+  rl.prompt();
+
+  for await (const rawLine of rl) {
+    const input = rawLine.trim();
+
+    // Skip empty lines
+    if (!input) {
+      rl.prompt();
+      continue;
+    }
+
+    // Handle slash commands
+    if (input.startsWith('/')) {
+      const handled = await handleSlashCommand(input, config, history);
+      if (handled) {
+        rl.prompt();
+        continue;
+      }
+    }
+
+    // ── LLM call ────────────────────────────────────────────────────────
+    try {
+      const userMessage = serializeHistory(history, input);
+
+      process.stdout.write(`\n  ${D}Thinking...${NC}`);
+      const response = await callLLM(config, systemPrompt, userMessage);
+      // Clear the "Thinking..." indicator
+      process.stdout.write('\r' + ' '.repeat(40) + '\r');
+
+      // Parse response for actions
+      const { textParts, actions } = parseActions(response);
+
+      // Display conversational text
+      if (textParts.length > 0) {
+        const text = textParts.join('\n\n');
+        console.log(`\n  ${W}${text}${NC}\n`);
+      }
+
+      // Execute actions
+      for (const { action, params } of actions) {
+        const isDestructive = DESTRUCTIVE_ACTIONS.has(action);
+
+        if (isDestructive) {
+          // Build a human-readable description of what will happen
+          const desc = describeAction(action, params);
+          const confirmed = await askConfirmation(rl, desc);
+
+          if (!confirmed) {
+            console.log(`  ${D}Cancelled.${NC}\n`);
+            history.push({ role: 'user', content: input });
+            history.push({ role: 'assistant', content: response + '\n[User cancelled this action]' });
+            continue;
+          }
+        }
+
+        // Execute the tool
+        try {
+          process.stdout.write(`  ${D}Executing ${action}...${NC}`);
+          const result = await executeTool(action, params, config);
+          process.stdout.write('\r' + ' '.repeat(60) + '\r');
+          console.log(`  ${G}Result:${NC}\n  ${result.split('\n').join('\n  ')}\n`);
+
+          // Feed result back into history so the LLM knows what happened
+          history.push({ role: 'user', content: input });
+          history.push({
+            role: 'assistant',
+            content: response + `\n\n[Tool ${action} executed. Result: ${result}]`,
+          });
+        } catch (err) {
+          process.stdout.write('\r' + ' '.repeat(60) + '\r');
+          console.log(`  ${R}Error executing ${action}: ${err.message}${NC}\n`);
+          history.push({ role: 'user', content: input });
+          history.push({
+            role: 'assistant',
+            content: response + `\n\n[Tool ${action} failed: ${err.message}]`,
+          });
+        }
+      }
+
+      // If no actions, just record the conversation turn
+      if (actions.length === 0) {
+        history.push({ role: 'user', content: input });
+        history.push({ role: 'assistant', content: response });
+      }
+
+      // Trim history to MAX_HISTORY turns (pairs of user+assistant)
+      while (history.length > MAX_HISTORY * 2) {
+        history.shift();
+        history.shift();
+      }
+    } catch (err) {
+      process.stdout.write('\r' + ' '.repeat(40) + '\r');
+      console.log(`\n  ${R}LLM error: ${err.message}${NC}\n`);
+    }
+
+    rl.prompt();
+  }
+}
+
+// ── Action Descriptor (for confirmation prompts) ─────────────────────────────
+
+function describeAction(action, params) {
+  switch (action) {
+    case 'gmail_send':
+      return `Send email to ${params.to} — Subject: "${params.subject}"`;
+    case 'gmail_reply':
+      return `Reply to message ${params.messageId}`;
+    case 'calendar_create':
+      return `Create event "${params.summary}" at ${formatTime(params.start)}`;
+    case 'calendar_move':
+      return `Reschedule event ${params.eventId} to ${formatTime(params.newStart)}`;
+    case 'task_done':
+      return `Mark task #${params.id} as completed`;
+    case 'notify_remind':
+      return `Set reminder: "${params.message}" at ${params.atTime}`;
+    default:
+      return `Execute ${action}`;
+  }
+}

package/src/constants.mjs

@@ -1,7 +1,7 @@
 import os from 'os';
 import path from 'path';
 
-export const VERSION = '2.0.0';
+export const VERSION = '2.1.0';
 export const BASE_URL = 'https://nothumanallowed.com/cli';
 export const API_BASE = 'https://nothumanallowed.com/api/v1';