@7ots/cli 0.1.1 → 0.1.4

package/.env.example

@@ -125,9 +125,21 @@ PLATFORM_DB=./data/platform.db
 PLATFORM_SECRET=
 PLATFORM_MAX_OTS=10
 PLATFORM_OTS_RATE_PER_MIN=120
+# Llamadas de chat y voz por ots y día (tope de gasto aunque alguien falsifique el Origin)
+PLATFORM_OTS_DAILY_LIMIT=1000
+# Cuentas nuevas por IP y día (cada una trae cupo gratis)
+PLATFORM_NEW_ACCOUNTS_PER_IP_DAY=3
+# Llamadas pagadas por la plataforma en curso a la vez por cuenta
+PLATFORM_MAX_INFLIGHT=4
 # IA y voz de la plataforma para los ots sin clave propia, con cupo gratis por cuenta y mes
+# PLATFORM_LLM_PROVIDER: anthropic | openai (y compatibles: DeepSeek, Groq… con PLATFORM_LLM_BASE_URL)
+PLATFORM_LLM_PROVIDER=
+PLATFORM_LLM_API_KEY=
+PLATFORM_LLM_BASE_URL=
+PLATFORM_LLM_MODEL=
+# Ejemplo DeepSeek: PLATFORM_LLM_PROVIDER=openai PLATFORM_LLM_BASE_URL=https://api.deepseek.com PLATFORM_LLM_MODEL=deepseek-flash
+# (compatibilidad: PLATFORM_ANTHROPIC_API_KEY=… equivale a provider anthropic con esa clave)
 PLATFORM_ANTHROPIC_API_KEY=
-PLATFORM_LLM_MODEL=claude-sonnet-5-5
 PLATFORM_FREE_MESSAGES=100
 PLATFORM_APUCHAT_VOICE_TOKEN=
 PLATFORM_FREE_TTS=100
@@ -138,3 +150,7 @@ PLATFORM_MAIL_TOKEN=
 NOTLOGIN_URL=https://notlogin.com
 NOTLOGIN_CLIENT_ID=
 NOTLOGIN_CLIENT_SECRET=
+# Identidades gratis de apuchat por cuenta y día (pestaña apuchat de cada ots; el hub es APUCHAT_HUB)
+PLATFORM_APUCHAT_IDENTITIES_PER_DAY=5
+# Orquesta: tareas que un ots puede encargar a un agente (OAuth con registro dinámico, sin client id fijo)
+ORQUESTA_URL=https://getorquesta.com

package/cli/7ots.mjs

@@ -4,8 +4,9 @@
  * `7ots help` lists the commands. Texts are English by default (es/pt: SEVENOTS_LANG, config or LANG).
  */
 
-import { spawn } from 'node:child_process';
-import { openSync } from 'node:fs';
+import { spawn, spawnSync } from 'node:child_process';
+import { existsSync, mkdirSync, openSync, writeFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
 import { join } from 'node:path';
 import { createIdentity, describe, identityPrompt, loadIdentity, cleanSeed } from './lib/identity.mjs';
 import { loadConfig } from './lib/config.mjs';
@@ -14,8 +15,8 @@ import { ensureHome, homeFile, PET_PORT, PKG_ROOT } from './lib/paths.mjs';
 import { applyEvent, loadPet, savePet, tick, view } from './lib/pet-core.mjs';
 import { petAlive, petToken, postPet, startPetServer } from './lib/pet-server.mjs';
 import { fromClaudeHook, installClaudeHooks, installShellHooks, redact, removeClaudeHooks, removeShellHooks } from './lib/hooks.mjs';
-import { findHtml, installHtml, platformLink, pretty, snippet } from './lib/install.mjs';
-import { promptText } from './lib/prompts.mjs';
+import { detectProject, findHtml, installHtml, platformLink, pretty, snippet } from './lib/install.mjs';
+import { llmsTxt, promptText } from './lib/prompts.mjs';
 import { openUrl, graphical } from './lib/open.mjs';
 
 const ELECTRON = 'electron@37';
@@ -42,7 +43,7 @@ function parse(argv) {
   }
   return { pos, flags };
 }
-const VALUED = new Set(['seed', 'name', 'lang', 'target', 'mode', 'type', 'code', 'cmd', 'tool', 'from', 'port', 'text', 'minutes']);
+const VALUED = new Set(['seed', 'name', 'lang', 'target', 'mode', 'type', 'code', 'cmd', 'tool', 'from', 'port', 'text', 'minutes', 'cancel']);
 
 const fail = (msg, code = 1) => {
   console.error(msg);
@@ -85,7 +86,14 @@ function cmdInstall({ pos, flags }) {
   const block = snippet(identity, { home });
   const html = target === 'print' ? null : pos[0] || findHtml();
   if (!html) {
-    console.log(t('install.noHtml') + '\n\n' + block + '\n');
+    const proj = detectProject();
+    if (proj.kind === 'none' && !pos[0] && target !== 'print') {
+      // Not a website: the snippet would be useless here; say what the ot can do instead.
+      console.log(t('install.notWeb', { name: identity.name, app }));
+      return;
+    }
+    const where = proj.file ? t('install.pasteIn', { file: proj.file, name: proj.name || '' }) : t('install.noHtml');
+    console.log(where + '\n\n' + block + '\n');
   } else {
     const r = installHtml(html, block);
     console.log(t(r.updated ? 'install.htmlUpdated' : 'install.html', { file: pretty(html) }));
@@ -131,42 +139,107 @@ async function spawnDaemon() {
   fail(`the pet did not start; see ${homeFile('pet.log')}`);
 }
 
-function petUrl(desktop = false) {
-  return `http://127.0.0.1:${PET_PORT}/pet?${desktop ? 'desktop=1&' : ''}token=${petToken()}`;
+function petUrl(desktop = false, view3d = false) {
+  return `http://127.0.0.1:${PET_PORT}/pet?${desktop ? 'desktop=1&' : ''}${view3d ? '3d=1&' : ''}token=${petToken()}`;
+}
+
+/** Path to the Electron binary, or null. `electron`'s index.js throws if its postinstall download never finished. */
+function electronBin(dir) {
+  try {
+    const bin = createRequire(join(dir, 'package.json'))('electron');
+    return typeof bin === 'string' && existsSync(bin) ? bin : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Electron lives in ~/.7ots/electron, installed once with npm in the foreground. Not `npx electron`:
+ * if npx is cut off mid-download (we used to detach it and close its pipes) its cache keeps a package
+ * without the binary and every later run fails with "electron: not found".
+ */
+function ensureElectron() {
+  const dir = homeFile('electron');
+  let bin = electronBin(dir);
+  if (bin) return { bin };
+  ensureHome();
+  console.log(dim(t('pet.electronInstall', { dir })));
+  if (!existsSync(join(dir, 'package.json'))) {
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, 'package.json'), '{ "name": "7ots-electron", "private": true }\n');
+  }
+  const r = spawnSync('npm', ['install', '--no-audit', '--no-fund', '--loglevel=error', ELECTRON], {
+    cwd: dir,
+    stdio: 'inherit',
+    shell: process.platform === 'win32',
+  });
+  bin = electronBin(dir);
+  return bin ? { bin } : { error: r.error?.message || `npm install ${ELECTRON} failed (exit ${r.status})` };
 }
 
 /** Electron window (detached). Resolves ok once it has stayed up for a few seconds. */
-function openDesktop() {
+function openDesktop({ opaque = false, view3d = false } = {}) {
   console.log(dim(t('pet.electron')));
-  const child = spawn('npx', ['-y', ELECTRON, join(PKG_ROOT, 'cli', 'pet', 'electron', 'main.cjs')], {
-    stdio: ['ignore', 'ignore', 'pipe'],
+  const { bin, error } = ensureElectron();
+  if (!bin) return Promise.resolve({ ok: false, error });
+  const log = openSync(homeFile('electron.log'), 'a');
+  const child = spawn(bin, [join(PKG_ROOT, 'cli', 'pet', 'electron', 'main.cjs')], {
+    stdio: ['ignore', log, log],
     detached: true,
-    env: { ...process.env, SEVENOTS_PET_URL: `http://127.0.0.1:${PET_PORT}`, SEVENOTS_PET_TOKEN: petToken() },
-    shell: process.platform === 'win32',
+    env: { ...process.env, SEVENOTS_PET_URL: `http://127.0.0.1:${PET_PORT}`, SEVENOTS_PET_TOKEN: petToken(), SEVENOTS_PET_OPAQUE: opaque ? '1' : '', SEVENOTS_PET_3D: view3d ? '1' : '', SEVENOTS_PET_LANG: cliLang() },
   });
   return new Promise((resolve) => {
-    let err = '';
-    child.stderr.on('data', (d) => (err = (err + d).slice(-400)));
-    child.once('error', (e) => resolve({ ok: false, error: e.message }));
-    // The first run downloads Electron: wait up to 3 min for it to either die or settle.
-    const began = Date.now();
-    let settled = began;
-    child.stderr.on('data', () => (settled = Date.now()));
-    const timer = setInterval(() => {
-      if (Date.now() - settled > 6000 || Date.now() - began > 180_000) {
-        clearInterval(timer);
-        child.stderr.destroy();
-        child.unref();
-        resolve({ ok: true });
-      }
-    }, 500);
-    child.once('exit', (code) => {
-      clearInterval(timer);
-      resolve(code ? { ok: false, error: (err.trim().split('\n').pop() || `exit ${code}`).slice(0, 160) } : { ok: true });
+    const timer = setTimeout(() => {
+      child.unref();
+      resolve({ ok: true });
+    }, 3000);
+    child.once('error', (e) => {
+      clearTimeout(timer);
+      resolve({ ok: false, error: e.message });
+    });
+    child.once('exit', (code, sig) => {
+      clearTimeout(timer);
+      resolve({ ok: false, error: `exit ${code ?? sig}; see ${homeFile('electron.log')}` });
     });
   });
 }
 
+/** Talk to the pet: reminders, notes, opening sites (the daemon's /ask). */
+async function cmdAsk({ pos }) {
+  const text = pos.join(' ').trim();
+  if (!text) fail(t('usage.ask'));
+  if (!(await petAlive())) fail(t('err.noPet'));
+  const r = await fetch(`http://127.0.0.1:${PET_PORT}/ask`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', 'X-7ots-Token': petToken() },
+    body: JSON.stringify({ text }),
+    signal: AbortSignal.timeout(60_000),
+  })
+    .then((x) => x.json())
+    .catch((e) => fail(e.message));
+  console.log(r.reply || '');
+}
+
+async function cmdReminders({ flags }) {
+  if (!(await petAlive())) fail(t('err.noPet'));
+  if (flags.cancel) {
+    const ok = await postPet('/reminders/cancel', { id: String(flags.cancel) });
+    return console.log(ok ? 'ok' : '?');
+  }
+  const r = await fetch(`http://127.0.0.1:${PET_PORT}/reminders?token=${petToken()}`).then((x) => x.json());
+  for (const x of r.reminders) console.log(`${dim(x.id)}  ${new Date(x.at).toLocaleString()}  ${x.text}${x.open ? dim(`  → ${x.open}`) : ''}`);
+  if (!r.reminders.length) console.log(dim('—'));
+  if (r.notes.length) console.log(`\n${bold('notes')}\n${r.notes.map((n) => `  · ${n.text}`).join('\n')}`);
+}
+
+/** The settings page (brain, what it may see, notes, reminders), in the browser. --print: only the URL. */
+async function cmdConfig({ flags }) {
+  if (!(await petAlive())) fail(t('err.noPet'));
+  const url = `http://127.0.0.1:${PET_PORT}/settings?token=${petToken()}`;
+  if (flags.print || !graphical() || !openUrl(url)) return console.log(url);
+  console.log(t('pet.settings'));
+}
+
 async function cmdPet({ flags }) {
   if (flags.daemon) {
     try {
@@ -180,8 +253,10 @@ async function cmdPet({ flags }) {
   }
 
   const { identity } = needIdentity();
+  if (flags.tmux) return petInTmux(identity, flags);
   const mode = await chooseMode(identity, flags);
   const detach = !!flags.detach;
+  const view3d = !!flags['3d'] || loadConfig().pet.view === '3d';
 
   let alive = await petAlive();
   let local = null;
@@ -197,24 +272,35 @@ async function cmdPet({ flags }) {
   if (mode === 'terminal') {
     const { runTerminal } = await import('./lib/terminal.mjs');
     const annoy = Number(loadConfig().pet.annoy ?? 2);
-    await runTerminal({ identity, lang: identity.language || cliLang(), port: PET_PORT, bell: annoy >= 3 });
+    await runTerminal({ identity, lang: cliLang(), port: PET_PORT, bell: annoy >= 3, compact: !!flags.compact || (process.stdout.columns || 80) < 44 });
     if (local) local.stop();
     return;
   }
 
   if (mode === 'desktop') {
-    const r = await openDesktop();
+    const r = await openDesktop({ opaque: !!flags.opaque || !!loadConfig().pet.opaque, view3d });
     if (!r.ok) {
       console.log(t('pet.electronFail', { error: r.error }));
-      openUrl(petUrl());
-    }
+      openUrl(petUrl(false, view3d));
+    } else console.log(t('pet.where', { name: identity.name }));
   } else {
-    openUrl(petUrl());
+    openUrl(petUrl(false, view3d));
     console.log(t('pet.running', { name: identity.name, url: `http://127.0.0.1:${PET_PORT}/pet` }));
   }
   console.log(t('pet.detached', { name: identity.name }));
 }
 
+/** The terminal pet in a tmux pane next to this one (the daemon lives on its own, so the pane can close). */
+async function petInTmux(identity, flags) {
+  if (!process.env.TMUX) fail(t('pet.tmuxNo'));
+  if (!(await petAlive())) await spawnDaemon();
+  const cmd = [process.execPath, join(PKG_ROOT, 'cli', '7ots.mjs'), 'pet', '--mode', 'terminal', ...(flags.compact ? ['--compact'] : [])]
+    .map((a) => `'${String(a).replace(/'/g, `'\\''`)}'`)
+    .join(' ');
+  const r = spawn('tmux', ['split-window', '-h', '-d', '-l', flags.compact ? '28' : '40', cmd], { stdio: 'inherit' });
+  r.once('exit', (code) => (code ? fail('tmux split-window failed') : console.log(t('pet.tmuxOk', { name: identity.name }))));
+}
+
 /** Events from hooks. Never fails loudly: a hook must not break the agent or the shell. */
 async function cmdEvent({ flags }) {
   let ev = null;
@@ -262,6 +348,11 @@ async function cmdStatus({ flags = {} } = {}) {
   } catch {}
   state ||= view(tick(loadPet()));
   if (flags.json) return console.log(JSON.stringify(state, null, 2));
+  if (flags.line) {
+    // Short and plain: made for the tmux status bar.
+    const low = Math.min(state.food, state.energy, state.fun) < 25 ? '!' : '';
+    return console.log(`${identity?.name || '7ots'}${state.asleep ? ' z' : ''} ♥${state.food} ⚡${state.energy} ★${state.fun}${low}`);
+  }
   console.log(
     t('pet.status', {
       name: identity?.name || '7ots',
@@ -336,6 +427,12 @@ async function main() {
   const [cmd = 'help', ...rest] = process.argv.slice(2);
   const args = parse(rest);
   if (args.flags.lang && ['en', 'es', 'pt'].includes(args.flags.lang)) (await import('./lib/i18n.mjs')).setCliLang(args.flags.lang);
+  // `7ots <cmd> --help` only prints usage: it never launches anything (the pet would download Electron).
+  if (args.flags.help && !['help', '--help', '-h'].includes(cmd)) {
+    const key = { create: 'new', serve: 'server', wizard: 'setup', init: 'setup' }[cmd] || cmd;
+    const usage = t(`usage.${key}`);
+    return console.log(usage === `usage.${key}` ? t('help') : usage);
+  }
   switch (cmd) {
     case 'new':
     case 'create':
@@ -363,6 +460,14 @@ async function main() {
     case 'wake':
     case 'say':
       return cmdCare(cmd, args);
+    case 'ask':
+    case 'tell':
+      return cmdAsk(args);
+    case 'reminders':
+      return cmdReminders(args);
+    case 'config':
+    case 'settings':
+      return cmdConfig(args);
     case 'status':
       return cmdStatus(args);
     case 'stop':
@@ -374,6 +479,9 @@ async function main() {
     case 'prompt':
     case 'prompts':
       return console.log(promptText(args.pos[0] || 'all'));
+    case 'docs':
+    case 'llms':
+      return console.log(llmsTxt('https://7ots.com'));
     case 'server':
     case 'serve':
       return import('../server/server.mjs'); // the 7ots proxy (reads .env / env vars)

package/cli/lib/assistant.mjs

@@ -0,0 +1,347 @@
+/**
+ * The pet as a small daily assistant: you tell it things and it acts.
+ *
+ *   "recuérdame ver el correo en 10 minutos"     → reminder; when due it speaks, notifies and opens Gmail
+ *   "remind me at 15:30 to call Ana"             → reminder
+ *   "anota que los viernes hay demo"             → a note it remembers (and the AI brain reads)
+ *   "abre el calendario" · "mis recordatorios" · "cancela los recordatorios" · "qué sabes de mí"
+ *
+ * With an AI brain (config.brain) the AI reads the request and answers with JSON actions; with
+ * `lines` (or if the AI fails) a local parser understands the common phrasings in en/es/pt.
+ * State: ~/.7ots/reminders.json and ~/.7ots/memory.json.
+ * Coming soon: seeing the screen / the running processes (opt-in) to suggest and do things.
+ */
+
+import { spawn } from 'node:child_process';
+import { randomBytes } from 'node:crypto';
+import { homeFile, readJson, writeJson } from './paths.mjs';
+import { openUrl } from './open.mjs';
+
+const SITES = [
+  [/\b(correo|mail|gmail|e-?mail|inbox|bandeja)\b/i, 'https://mail.google.com', { en: 'your email', es: 'tu correo', pt: 'seu e-mail' }],
+  [/\b(calendario|calendar|agenda|calend[aá]rio)\b/i, 'https://calendar.google.com', { en: 'your calendar', es: 'tu calendario', pt: 'sua agenda' }],
+  [/\bwhats ?app\b/i, 'https://web.whatsapp.com', { en: 'WhatsApp', es: 'WhatsApp', pt: 'WhatsApp' }],
+  [/\bslack\b/i, 'https://app.slack.com', { en: 'Slack', es: 'Slack', pt: 'Slack' }],
+  [/\bgithub\b/i, 'https://github.com', { en: 'GitHub', es: 'GitHub', pt: 'GitHub' }],
+  [/\b(drive)\b/i, 'https://drive.google.com', { en: 'Drive', es: 'Drive', pt: 'Drive' }],
+  [/\blinked ?in\b/i, 'https://www.linkedin.com', { en: 'LinkedIn', es: 'LinkedIn', pt: 'LinkedIn' }],
+  [/\b(twitter|x\.com)\b/i, 'https://x.com', { en: 'X', es: 'X', pt: 'X' }],
+  [/\b(google meet|meet)\b/i, 'https://meet.google.com', { en: 'Meet', es: 'Meet', pt: 'Meet' }],
+];
+
+const T = {
+  en: {
+    when: 'When? For example "in 10 minutes" or "at 15:30".',
+    set: (r) => `Got it: I'll remind you to ${r.text} at ${hhmm(r.at)}${r.open ? ' and open it for you' : ''}.`,
+    none: 'No pending reminders.',
+    list: (rs) => `Pending: ${rs.map((r) => `${hhmm(r.at)} ${r.text}`).join(' · ')}`,
+    cancelled: (n) => `Cancelled ${n} reminder${n === 1 ? '' : 's'}.`,
+    noted: 'Noted, I will remember it.',
+    know: (ns) => (ns.length ? `I remember: ${ns.map((n) => n.text).join(' · ')}` : "I don't know much about you yet. Tell me \"remember that…\"."),
+    opening: (s) => `Opening ${s}.`,
+    fire: (r) => `Reminder: ${r.text}!`,
+    help: 'I can set reminders ("remind me to check email in 10 minutes"), open sites ("open my calendar") and remember notes ("remember that…"). Seeing your screen: coming soon.',
+  },
+  es: {
+    when: '¿Para cuándo? Por ejemplo "en 10 minutos" o "a las 15:30".',
+    set: (r) => `Listo: te recuerdo ${r.text} a las ${hhmm(r.at)}${r.open ? ' y te lo abro' : ''}.`,
+    none: 'No tienes recordatorios pendientes.',
+    list: (rs) => `Pendientes: ${rs.map((r) => `${hhmm(r.at)} ${r.text}`).join(' · ')}`,
+    cancelled: (n) => `Cancelé ${n} recordatorio${n === 1 ? '' : 's'}.`,
+    noted: 'Anotado, lo voy a recordar.',
+    know: (ns) => (ns.length ? `Recuerdo: ${ns.map((n) => n.text).join(' · ')}` : 'Todavía sé poco de ti. Dime "anota que…".'),
+    opening: (s) => `Abriendo ${s}.`,
+    fire: (r) => `¡Recordatorio: ${r.text}!`,
+    help: 'Puedo poner recordatorios ("recuérdame ver el correo en 10 minutos"), abrir sitios ("abre mi calendario") y recordar notas ("anota que…"). Ver tu pantalla: muy pronto.',
+  },
+  pt: {
+    when: 'Para quando? Por exemplo "em 10 minutos" ou "às 15:30".',
+    set: (r) => `Feito: te lembro de ${r.text} às ${hhmm(r.at)}${r.open ? ' e abro pra você' : ''}.`,
+    none: 'Nenhum lembrete pendente.',
+    list: (rs) => `Pendentes: ${rs.map((r) => `${hhmm(r.at)} ${r.text}`).join(' · ')}`,
+    cancelled: (n) => `Cancelei ${n} lembrete${n === 1 ? '' : 's'}.`,
+    noted: 'Anotado, vou lembrar.',
+    know: (ns) => (ns.length ? `Eu lembro: ${ns.map((n) => n.text).join(' · ')}` : 'Ainda sei pouco de você. Diga "anote que…".'),
+    opening: (s) => `Abrindo ${s}.`,
+    fire: (r) => `Lembrete: ${r.text}!`,
+    help: 'Posso criar lembretes ("me lembre de ver o e-mail em 10 minutos"), abrir sites ("abra minha agenda") e lembrar notas ("anote que…"). Ver sua tela: em breve.',
+  },
+};
+
+/** The language the human wrote in (replies follow it), or null. */
+export function langOf(text) {
+  const s = String(text || '').toLowerCase();
+  if (W('[ãõç]|\\b(me lembre|lembre|lembrete|voc[eê]|abra minha|anote|meus|daqui a|amanh[aã])\\b', 'u').test(s)) return 'pt';
+  if (W('[ñ¿¡]|\\b(recu[eé]rd|recordame|av[ií]same|anota|apunta|abre|abr[ií]|mis|qu[eé]|ma[nñ]ana|minutos|a las|correo|cancela)\\b', 'u').test(s)) return 'es';
+  if (/\b(remind|remember|open|my|what|tomorrow|minutes?|at \d)\b/.test(s)) return 'en';
+  return null;
+}
+
+const hhmm = (at) => new Date(at).toTimeString().slice(0, 5);
+const tr = (lang) => T[lang] || T.en;
+
+// ── local parser ──
+
+// \b does not see accented letters (é, í, ã, à) as word characters: unicode-aware boundaries.
+const B = '(?<![\\p{L}\\d])';
+const E = '(?![\\p{L}\\d])';
+const W = (src, flags = 'iu') => new RegExp(src.replaceAll('\\b(', `${B}(`).replaceAll(')\\b', `)${E}`), flags);
+
+const NUM = { un: 1, una: 1, uno: 1, uma: 1, um: 1, a: 1, an: 1, one: 1, dos: 2, two: 2, 'dois': 2, tres: 3, three: 3, 'três': 3, cinco: 5, five: 5, diez: 10, ten: 10, dez: 10, quince: 15, fifteen: 15, quinze: 15, veinte: 20, twenty: 20, vinte: 20, treinta: 30, thirty: 30, trinta: 30 };
+const UNIT = (u) => (/^(s|seg|sec)/.test(u) ? 1000 : /^(h|hr|hora|hour)/.test(u) ? 3_600_000 : 60_000);
+const IN_RE = W('\\b(?:en|in|em|dentro de|daqui a)\\s+(\\d+|un|una|uno|uma|um|an?|one|dos|two|dois|tres|three|três|cinco|five|diez|ten|dez|quince|fifteen|quinze|veinte|twenty|vinte|treinta|thirty|trinta)\\s*(segundos?|seg|secs?|seconds?|s|minutos?|mins?|minutes?|m|horas?|hours?|hrs?|h)\\b');
+const HALF_RE = W('\\b(?:en|in|em|dentro de)\\s+(?:media hora|half an hour|meia hora)\\b');
+const AT_RE = W('\\b(?:a las|a la|at|às|as)\\s+(\\d{1,2})(?:[:.h](\\d{2}))?\\s*(am|pm|hrs?|horas?)?\\b');
+const TOMORROW_RE = W('\\b(mañana|manana|tomorrow|amanh[aã])\\b');
+const REMIND_RE = W('\\b(recu[eé]rd[aá]me|recordame|recu[eé]rdame|av[ií]same|remind me|me lembr[ae]|lembre-me|lembra-me)\\b');
+const NOTE_RE = W('^\\s*(?:anota(?:\\s+que)?|apunta(?:\\s+que)?|recuerda que|aprende que|remember(?:\\s+that)?|note(?:\\s+that)?|anote(?:\\s+que)?|lembre que|lembra que)\\s+');
+const OPEN_RE = W('^\\s*(?:abre|abr[ií]|abrime|[aá]breme|open|abra|abrir)\\b');
+const LIST_RE = W('\\b(mis recordatorios|qu[eé] recordatorios|recordatorios pendientes|my reminders|list reminders|reminders|meus lembretes|lembretes)\\b');
+const CANCEL_RE = W('\\b(cancela|borra|elimina|cancel|clear|apaga|remove)\\b.*\\b(recordatorios?|reminders?|lembretes?)\\b');
+const KNOW_RE = W('\\b(qu[eé] (?:sabes|recuerdas)|what do you (?:know|remember)|o que (?:voc[eê] )?(?:sabe|lembra))\\b');
+const HELP_RE = W('^\\s*(ayuda|help|ajuda|qu[eé] puedes hacer|what can you do|o que voc[eê] pode fazer)\\s*\\??\\s*$');
+
+function siteOf(text) {
+  const url = text.match(/https?:\/\/[^\s]+/i)?.[0];
+  if (url) return { url, label: url };
+  for (const [re, u, label] of SITES) if (re.test(text)) return { url: u, label };
+  return null;
+}
+
+/** When, from a phrase. Returns epoch ms or null. */
+export function parseWhen(text, now = Date.now()) {
+  if (HALF_RE.test(text)) return now + 30 * 60_000;
+  const m = text.match(IN_RE);
+  if (m) {
+    const n = /^\d+$/.test(m[1]) ? Number(m[1]) : NUM[m[1].toLowerCase()] || 1;
+    return now + n * UNIT(m[2].toLowerCase());
+  }
+  const a = text.match(AT_RE);
+  const tomorrow = TOMORROW_RE.test(text);
+  if (a) {
+    let h = Number(a[1]);
+    const min = Number(a[2] || 0);
+    if (/pm/i.test(a[3] || '') && h < 12) h += 12;
+    if (/am/i.test(a[3] || '') && h === 12) h = 0;
+    if (h > 23 || min > 59) return null;
+    const d = new Date(now);
+    d.setHours(h, min, 0, 0);
+    if (tomorrow) d.setDate(d.getDate() + 1);
+    else if (d.getTime() <= now) d.setDate(d.getDate() + 1); // "a las 9" said at 10 → tomorrow
+    return d.getTime();
+  }
+  if (tomorrow) {
+    const d = new Date(now);
+    d.setDate(d.getDate() + 1);
+    d.setHours(9, 0, 0, 0);
+    return d.getTime();
+  }
+  return null;
+}
+
+/** What to remember, without the trigger and the time words. */
+function reminderText(text) {
+  const s = text
+    .replace(REMIND_RE, ' ')
+    .replace(HALF_RE, ' ')
+    .replace(IN_RE, ' ')
+    .replace(AT_RE, ' ')
+    .replace(TOMORROW_RE, ' ')
+    .replace(/\by (?:que )?(?:t[uú] mismo |él mismo |el mismo |ella misma )?(?:me )?(?:abras?|abre|abr[ií]|open|abra)\b.*$/i, ' ') // "…y que me abras la pestaña"
+    .replace(/\band (?:then )?open\b.*$/i, ' ')
+    .replace(/^\s*(?:de |que |to |that |para )/i, ' ')
+    .replace(/\s+/g, ' ')
+    .replace(/^[\s,.:;-]+|[\s,.:;!?-]+$/g, '')
+    .replace(/^(?:de|que|to|that|para)\s+/i, '');
+  return s || text.trim();
+}
+
+/** Local understanding → list of actions. */
+export function parseLocal(text, now = Date.now()) {
+  const s = String(text || '').trim();
+  if (!s) return [];
+  if (HELP_RE.test(s)) return [{ type: 'help' }];
+  if (CANCEL_RE.test(s)) return [{ type: 'cancel' }];
+  if (LIST_RE.test(s) && !REMIND_RE.test(s)) return [{ type: 'list' }];
+  if (KNOW_RE.test(s)) return [{ type: 'know' }];
+  if (NOTE_RE.test(s)) return [{ type: 'note', text: s.replace(NOTE_RE, '').trim() }];
+  const site = siteOf(s);
+  const at = parseWhen(s, now);
+  if (REMIND_RE.test(s) || at) {
+    if (!at) return [{ type: 'ask_when' }];
+    return [{ type: 'remind', at, text: reminderText(s), open: site?.url || null }];
+  }
+  if (OPEN_RE.test(s) && site) return [{ type: 'open', url: site.url, label: site.label }];
+  return [];
+}
+
+// ── AI understanding ──
+
+function aiPrompt(text, { lang, notes, reminders, now }) {
+  return [
+    `Your human wrote to you: """${String(text).slice(0, 800)}"""`,
+    `Now it is ${new Date(now).toString()}.`,
+    notes.length ? `What you know about them: ${notes.map((n) => `- ${n.text}`).join('\n')}` : '',
+    reminders.length ? `Pending reminders: ${reminders.map((r) => `${new Date(r.at).toString()}: ${r.text}`).join('; ')}` : '',
+    `You can act. Answer ONLY with one JSON object, no prose around it:`,
+    `{"reply":"one short line in character, in the human's language","actions":[...]}`,
+    `Actions: {"type":"remind","in_minutes":N | "at":"ISO-8601 local time","text":"what to remind (short, imperative)","open":"https://… or null"}`,
+    `{"type":"open","url":"https://…"} (open now) · {"type":"note","text":"a durable fact or preference worth remembering"} · {"type":"cancel"} (all pending reminders) · {"type":"list"}`,
+    `When a reminder is about a website (email → https://mail.google.com, calendar → https://calendar.google.com, etc.) set "open" so it opens when due.`,
+    `If they share something about their work, routine or preferences, add a note. If a reminder has no time, ask when in "reply" with no actions.`,
+    `Reply in ${{ es: 'Spanish', pt: 'Portuguese' }[lang] || 'English'}.`,
+  ]
+    .filter(Boolean)
+    .join('\n');
+}
+
+function parseAi(raw, now) {
+  const m = String(raw || '').match(/\{[\s\S]*\}/);
+  if (!m) return null;
+  let j;
+  try {
+    j = JSON.parse(m[0]);
+  } catch {
+    return null;
+  }
+  const actions = [];
+  for (const a of Array.isArray(j.actions) ? j.actions : []) {
+    if (a?.type === 'remind') {
+      const at = Number.isFinite(Number(a.in_minutes)) && a.in_minutes !== null && a.in_minutes !== '' ? now + Number(a.in_minutes) * 60_000 : Date.parse(a.at);
+      if (Number.isFinite(at) && at > now - 60_000 && a.text) actions.push({ type: 'remind', at, text: String(a.text).slice(0, 200), open: safeUrl(a.open) });
+    } else if (a?.type === 'open' && safeUrl(a.url)) actions.push({ type: 'open', url: safeUrl(a.url), label: a.url });
+    else if (a?.type === 'note' && a.text) actions.push({ type: 'note', text: String(a.text).slice(0, 300) });
+    else if (['cancel', 'list'].includes(a?.type)) actions.push({ type: a.type });
+  }
+  return { reply: String(j.reply || '').slice(0, 400), actions };
+}
+
+const safeUrl = (u) => (typeof u === 'string' && /^https?:\/\/[^\s"'<>]+$/i.test(u) ? u : null);
+
+// ── the assistant ──
+
+/** Desktop notification, best effort. */
+function notify(title, body) {
+  const [cmd, args] =
+    process.platform === 'darwin'
+      ? ['osascript', ['-e', `display notification ${JSON.stringify(body)} with title ${JSON.stringify(title)}`]]
+      : process.platform === 'win32'
+        ? [null, []]
+        : ['notify-send', ['-a', '7ots', '-u', 'critical', title, body]];
+  if (!cmd) return;
+  try {
+    spawn(cmd, args, { stdio: 'ignore', detached: true }).on('error', () => {}).unref();
+  } catch {}
+}
+
+/**
+ * @param {{ brain, system: () => string, lang: string, name: string, onFire: (reminder, line) => void, access?: () => object, log?: Function }} o
+ *   access()  config.access: memory (keep/use notes), open (open sites), notify (desktop notifications)
+ */
+export function createAssistant({ brain, system, lang, name, onFire, access = () => ({}), log = () => {} }) {
+  const may = (k) => access()[k] !== false;
+  let L = tr(lang);
+  const remF = homeFile('reminders.json');
+  const memF = homeFile('memory.json');
+  let reminders = (readJson(remF, []) || []).filter((r) => r && !r.done);
+  let notes = readJson(memF, []) || [];
+  const saveR = () => writeJson(remF, reminders);
+  const saveN = () => writeJson(memF, notes.slice(-200));
+
+  function fire(r) {
+    r.done = true;
+    const line = tr(r.lang || lang).fire(r);
+    if (may('notify')) notify(`${name} · 7ots`, r.text);
+    if (r.open && may('open')) openUrl(r.open);
+    onFire(r, line);
+  }
+
+  // A minute late is fine; missed while the daemon was down → fire on start (once).
+  const timer = setInterval(() => {
+    const now = Date.now();
+    let changed = false;
+    for (const r of reminders) if (!r.done && r.at <= now) (fire(r), (changed = true));
+    if (changed) {
+      reminders = reminders.filter((r) => !r.done);
+      saveR();
+    }
+  }, 5000);
+  timer.unref?.();
+
+  function run(actions) {
+    const out = [];
+    for (const a of actions) {
+      if ((a.type === 'note' && !may('memory')) || (a.type === 'open' && !may('open'))) continue;
+      if (a.type === 'remind') {
+        const r = { id: randomBytes(4).toString('hex'), at: a.at, text: a.text, open: (may('open') && a.open) || null, lang: L === T.es ? 'es' : L === T.pt ? 'pt' : 'en', created: Date.now() };
+        reminders.push(r);
+        reminders.sort((x, y) => x.at - y.at);
+        saveR();
+        out.push(L.set(r));
+      } else if (a.type === 'open') {
+        openUrl(a.url);
+        out.push(L.opening(typeof a.label === 'object' ? a.label[L === T.es ? 'es' : L === T.pt ? 'pt' : 'en'] : a.label));
+      } else if (a.type === 'note') {
+        notes.push({ text: a.text, at: Date.now() });
+        saveN();
+        out.push(L.noted);
+      } else if (a.type === 'cancel') {
+        const n = reminders.length;
+        reminders = [];
+        saveR();
+        out.push(L.cancelled(n));
+      } else if (a.type === 'list') out.push(reminders.length ? L.list(reminders) : L.none);
+      else if (a.type === 'know') out.push(L.know(may('memory') ? notes.slice(-12) : []));
+      else if (a.type === 'ask_when') out.push(L.when);
+      else if (a.type === 'help') out.push(L.help);
+    }
+    return out;
+  }
+
+  return {
+    get reminders() {
+      return reminders.slice();
+    },
+    get notes() {
+      return notes.slice();
+    },
+    /** Free text → { reply, actions }. Never throws. */
+    async ask(text) {
+      const now = Date.now();
+      const said = langOf(text) || lang;
+      L = tr(said);
+      const local = parseLocal(text, now);
+      let ai = null;
+      if (brain.kind !== 'lines') {
+        try {
+          const raw = await brain.think({ system: system(), messages: [{ role: 'user', content: aiPrompt(text, { lang: said, notes: may('memory') ? notes.slice(-30) : [], reminders, now }) }], timeoutMs: 45000, raw: true });
+          ai = parseAi(raw, now);
+        } catch (e) {
+          log(`assistant: ${e.message}`);
+        }
+      }
+      if (ai && (ai.actions.length || !local.length)) {
+        const done = run(ai.actions);
+        return { reply: ai.reply || done.join(' ') || L.help, actions: ai.actions };
+      }
+      const done = run(local);
+      return { reply: done.join(' ') || L.help, actions: local };
+    },
+    /** Forget one note (by its timestamp, stable across the list) or all of them. */
+    forget(at) {
+      const n = notes.length;
+      notes = at === 'all' ? [] : notes.filter((x) => String(x.at) !== String(at));
+      saveN();
+      return n !== notes.length;
+    },
+    cancel(id) {
+      const n = reminders.length;
+      reminders = reminders.filter((r) => r.id !== id);
+      saveR();
+      return n !== reminders.length;
+    },
+    stop() {
+      clearInterval(timer);
+    },
+  };
+}