@7ots/cli 0.1.4 → 0.1.6

package/README.md

@@ -1,28 +1,22 @@
 <p align="center"><img src="brand/wordmark.svg" alt="7ots" width="220"></p>
 
-<p align="center"><b>Tu web, con alguien dentro.</b><br>
-Un agente web open source que ve la página, habla y actúa por tu visitante. Se instala con una etiqueta <code>&lt;script&gt;</code>.<br>
-<a href="https://7ots.com">7ots.com</a> · <a href="docs/ARCHITECTURE.md">Arquitectura</a> · <a href="docs/BRAND.md">Marca</a></p>
+<p align="center"><b>Tu compañero de IA, con cara propia.</b><br>
+Un ot es tu compañero de IA con cara, personalidad y voz: vive en tu escritorio como mascota, cuida a tu agente de código, te recuerda cosas, entra a tus videollamadas y puede ser tu asistente en Orquesta.<br>
+<a href="https://7ots.com">7ots.com</a> · <a href="llms.txt">llms.txt</a> · <a href="docs/ARCHITECTURE.md">Arquitectura</a> · <a href="docs/BRAND.md">Marca</a></p>
 
-7ots mete en tu web un agente con avatar 3D que *entiende la página*, *actúa sobre ella*
-(navega, pulsa, rellena formularios, resalta, abre modales), usa las APIs y el **MCP
-autenticado** de tu sitio con la sesión del usuario, y cuando hace falta deriva a una persona
-por **apuchat.com** o abre un ticket por **apumail.com**.
-
-```
-┌──────────── tu sitio ────────────┐          ┌──── server/ (tu proxy) ────┐
-│  <ots-agent>  (Shadow DOM)        │  /chat   │  Claude u OpenAI           │
-│   avatar 3D · chat · voz          │ ───────► │  TTS (OpenAI / ElevenLabs) │
-│   ContextManager ← DOM, rutas     │          │  apumail · apuchat         │
-│   ActionRegistry → click, forms…  │          │  claves en .env            │
-│   McpClient ──► /mcp (JWT)        │          └────────────────────────────┘
-└───────────────────────────────────┘
+```bash
+npx @7ots/cli pet                    # tu ot se muda a tu escritorio
+npx @7ots/cli hooks install --claude # y escucha a Claude Code (aciertos, errores, permisos)
 ```
 
-- **Cero dependencias en el navegador.** Web Component nativo con Shadow DOM: no rompe tu CSS ni el tuyo lo rompe.
-- **Las claves nunca llegan al navegador.** Todo pasa por un proxy Node sin estado (`server/`).
-- **Proactivo, sin ser pesado.** Saluda, detecta errores de formulario, dudas largas en una sección… con límites de frecuencia y un botón de silencio.
-- **Seguro por diseño.** Solo ejecuta herramientas registradas, valida argumentos contra JSON Schema, pide confirmación real antes de acciones con efectos, no lee campos de contraseña ni bloques `data-ots-private`, y trata el contenido de la página como datos, no como órdenes.
+- **Mascota de escritorio.** Ventana siempre visible, terminal o tmux; tiene necesidades, sube de nivel y comenta tu trabajo.
+- **Cuida a tu agente de código.** Hooks de Claude Code, Codex y la shell: te avisa cuando termina, falla o te pide permiso.
+- **Asistente.** Recordatorios, alertas de precios y procesos, conciencia de pantalla opcional (apagada por defecto) y voz local.
+- **Videollamadas y Orquesta.** Entra a llamadas de apuchat con su avatar; conectado a Orquesta, vive en un proyecto y lanza tareas.
+- **Para dueños de sitios, APIs y MCP.** Registra tu servicio en [7ots.com/app#sites](https://7ots.com/app#sites) con una guía de uso
+  y verificación por DNS TXT, `/.well-known` o etiqueta meta, para que todos los ots sepan cuándo y cómo usarlo (impulsado por [Prowl.world](https://prowl.world)).
+
+> **Legacy / widget web self-hosted:** lo que sigue documenta el SDK embebible (`<ots-agent>`, `embed.js`, proxy). Sigue funcionando, pero ya no es el producto principal: instálalo solo si lo pides explícitamente.
 
 > Estado: `0.1.0` — prototipo funcional. APIs sujetas a cambios.
 

package/cli/7ots.mjs

@@ -43,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', 'cancel']);
+const VALUED = new Set(['seed', 'name', 'lang', 'target', 'mode', 'type', 'code', 'cmd', 'tool', 'from', 'port', 'text', 'minutes', 'cancel', 'server']);
 
 const fail = (msg, code = 1) => {
   console.error(msg);
@@ -415,10 +415,52 @@ async function cmdMeet({ pos, flags }) {
 /* ───────────── orquesta ───────────── */
 
 async function cmdLogin({ pos }) {
-  if ((pos[0] || 'orquesta') !== 'orquesta') return fail('7ots login orquesta');
-  const { login } = await import('./lib/orquesta.mjs');
-  const r = await login({ open: openUrl, onWaiting: (url) => console.log(t('login.open', { url })) });
-  console.log(t('login.ok', { org: r.organizationName || r.organizationId }));
+  if (pos[0] === 'orquesta') {
+    const { login } = await import('./lib/orquesta.mjs');
+    const r = await login({ open: openUrl, onWaiting: (url) => console.log(t('login.open', { url })) });
+    return console.log(t('login.ok', { org: r.organizationName || r.organizationId }));
+  }
+  if (pos[0] && pos[0] !== '7ots') return fail('7ots login [orquesta]');
+  const acct = await import('./lib/account.mjs');
+  const { url, done } = await acct.startLogin({ open: openUrl });
+  console.log(t('login.open', { url }));
+  await done;
+  const { account } = await acct.me();
+  console.log(t('acct.ok', { who: account?.email || account?.name || '' }));
+  return cmdOts();
+}
+
+/* ───────────── vm (cloud worker of an ot) ───────────── */
+
+async function cmdVm({ pos, flags }) {
+  const vm = await import('./lib/vm.mjs');
+  if (pos[0] === 'enroll') return console.log(await vm.enroll({ server: flags.server, code: flags.code, systemd: Boolean(flags.systemd) }));
+  if (pos[0] === 'worker') return vm.runWorker({ log: (s) => console.log(`[${new Date().toISOString()}] ${s}`) });
+  return fail(t('vm.usage'));
+}
+
+async function cmdLogout() {
+  const acct = await import('./lib/account.mjs');
+  await acct.logout();
+  console.log(t('acct.out'));
+}
+
+// `7ots ots`: the ots in your 7ots.com account (★ = the one on this computer).
+async function cmdOts() {
+  const acct = await import('./lib/account.mjs');
+  if (!acct.signedIn()) return console.log(t('acct.none'));
+  const { ots = [] } = await acct.me();
+  if (!ots.length) return console.log(t('acct.empty', { url: acct.SEVENOTS_URL }));
+  const cur = loadConfig().account?.otsId;
+  for (const o of ots) console.log(`${o.id === cur ? '★' : ' '} ${o.id}  ${o.identity?.name || o.name}`);
+}
+
+async function cmdUse({ pos }) {
+  if (!pos[0]) return fail('7ots use <ot-id>');
+  const acct = await import('./lib/account.mjs');
+  if (!acct.signedIn()) return console.log(t('acct.none'));
+  const { identity } = await acct.use(pos[0]);
+  console.log(t('acct.used', { name: identity.name }));
 }
 
 /* ───────────── main ───────────── */
@@ -487,6 +529,14 @@ async function main() {
       return import('../server/server.mjs'); // the 7ots proxy (reads .env / env vars)
     case 'login':
       return cmdLogin(args);
+    case 'logout':
+      return cmdLogout();
+    case 'vm':
+      return cmdVm(args);
+    case 'ots':
+      return cmdOts();
+    case 'use':
+      return cmdUse(args);
     case 'seed':
       return console.log(cleanSeed(args.pos[0]) || '');
     case 'help':

package/cli/lib/account.mjs

@@ -0,0 +1,89 @@
+/**
+ * Your 7ots.com account on this computer: sign in once, then the pet can list your ots,
+ * become another one and bring its settings (identity, look, voice, personality).
+ *
+ *   login()    device flow (server/platform/device.mjs): POST /api/device/start, open
+ *              /app/#device/<code>, you press Connect, we poll for a 7d_ token
+ *              (saved as SEVENOTS_TOKEN in ~/.7ots/keys.json, 0600)
+ *   me()       { account, ots: [summary] }
+ *   pull(id)   { ots, identity }: everything the ot has on 7ots.com
+ *   use(id)    makes that ot this computer's pet (~/.7ots/identity.json; the previous one is
+ *              kept in identity.prev.json) and points its home at 7ots.com
+ *   logout()   revokes the token on 7ots.com and forgets it here
+ */
+
+import { hostname } from 'node:os';
+import { copyFileSync, existsSync } from 'node:fs';
+import { env, loadConfig, saveConfig, saveKey } from './config.mjs';
+import { homeFile, writeJson } from './paths.mjs';
+import { defineIdentity } from '../../src/identity/schema.js';
+
+export const SEVENOTS_URL = (process.env.SEVENOTS_URL || 'https://7ots.com').replace(/\/+$/, '');
+
+async function api(path, { token = env().SEVENOTS_TOKEN, method = 'GET', body } = {}) {
+  const res = await fetch(`${SEVENOTS_URL}/api/device${path}`, {
+    method,
+    headers: { ...(token ? { Authorization: `Bearer ${token}` } : {}), ...(body ? { 'Content-Type': 'application/json' } : {}) },
+    body: body ? JSON.stringify(body) : undefined,
+    signal: AbortSignal.timeout(15000),
+  });
+  const data = await res.json().catch(() => ({}));
+  if (res.status === 401 && token) saveKey('SEVENOTS_TOKEN', ''); // revoked from the dashboard
+  if (!res.ok && res.status !== 202) throw Object.assign(new Error(data.error || `HTTP ${res.status}`), { status: res.status });
+  return { status: res.status, ...data };
+}
+
+export const signedIn = () => Boolean(env().SEVENOTS_TOKEN);
+
+/**
+ * Starts signing in. Returns { url, done } right away so a UI can show the link; `done`
+ * resolves with me() once approved (or rejects: denied / expired).
+ */
+export async function startLogin({ open } = {}) {
+  const { code, url, expiresIn } = await api('/start', { method: 'POST', token: '', body: { name: `7ots pet · ${hostname()}` } });
+  open?.(url);
+  const done = (async () => {
+    const end = Date.now() + expiresIn * 1000;
+    while (Date.now() < end) {
+      await new Promise((r) => setTimeout(r, 2000));
+      let r;
+      try {
+        r = await api('/poll', { method: 'POST', token: '', body: { code } });
+      } catch (e) {
+        if (e.status === 410) throw e;
+        continue; // network hiccup: keep waiting
+      }
+      if (r.token) {
+        saveKey('SEVENOTS_TOKEN', r.token);
+        return me();
+      }
+    }
+    throw Object.assign(new Error('expired'), { status: 410 });
+  })();
+  done.catch(() => {}); // the caller may not await it
+  return { url, done };
+}
+
+export const me = () => api('/me');
+export const pull = (id) => api(`/ots/${encodeURIComponent(id)}`);
+
+export async function use(id) {
+  const { ots, identity } = await pull(id);
+  const file = homeFile('identity.json');
+  if (existsSync(file)) copyFileSync(file, homeFile('identity.prev.json'));
+  writeJson(file, defineIdentity(identity));
+  const config = loadConfig();
+  config.account = { otsId: ots.id, name: ots.identity?.name || ots.name, at: Date.now() };
+  // An Orquesta or self-hosted home stays put: only the look and personality come from 7ots.com.
+  if (['local', '7ots'].includes(config.home?.kind || 'local')) config.home = { kind: '7ots', url: `${SEVENOTS_URL}/api/o/${ots.id}` };
+  saveConfig(config);
+  return { ots, identity };
+}
+
+export async function logout() {
+  if (signedIn()) await api('/token', { method: 'DELETE' }).catch(() => {});
+  saveKey('SEVENOTS_TOKEN', '');
+  const config = loadConfig();
+  delete config.account;
+  saveConfig(config);
+}

package/cli/lib/assistant.mjs

@@ -9,13 +9,19 @@
  * 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.
+ *   "avísame si BTC llega a 85 mil" · "avísame cuando termine el build"  → a watcher (watchers.mjs)
+ * With access.processes it also knows what runs on the computer (the busiest processes).
+ * `extra` (integrations.mjs) adds actions that fetch something (logs, email, Orquesta agents, custom
+ * integrations): what they bring back goes to the brain once more for the final reply.
+ * With access.vm and a cloud worker (vm.mjs) it can `offload` long work ("investiga…", "lee estas
+ * páginas…") to the ot's server: progress as `say` (≤1 every 20 s), result to memory/notification.
  */
 
 import { spawn } from 'node:child_process';
 import { randomBytes } from 'node:crypto';
 import { homeFile, readJson, writeJson } from './paths.mjs';
 import { openUrl } from './open.mjs';
+import { followJob, submitJob } from './vm.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' }],
@@ -31,6 +37,8 @@ const SITES = [
 
 const T = {
   en: {
+    watch: (w) => (w.kind === 'price' ? `Watching ${w.coin}: I'll tell you when it is ${w.op} ${fmt(w.value)} ${w.vs.toUpperCase()}.` : `Watching "${w.match}": I'll tell you when it ${w.until === 'start' ? 'starts' : 'ends'}.`),
+    watchFire: (w, n) => (w.kind === 'price' ? `${w.coin} is at ${fmt(n.price)} ${w.vs.toUpperCase()}!${w.text ? ` ${w.text}` : ''}` : `"${w.match}" ${w.until === 'start' ? 'started' : 'finished'}.${w.text ? ` ${w.text}` : ''}`),
     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.',
@@ -40,9 +48,16 @@ const T = {
     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}!`,
+    offload: (k) => `On it: I sent it to my server (${k}). I'll tell you how it goes.`,
+    offloadQueued: 'Queued: my server is offline right now, it will start when it is back.',
+    offloadStep: (s) => `Still working: ${s}`,
+    offloadDone: (r) => `Done: ${r}`,
+    offloadFail: (e) => `My server could not finish it: ${e}`,
     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: {
+    watch: (w) => (w.kind === 'price' ? `Vigilando ${w.coin}: te aviso cuando esté ${w.op} ${fmt(w.value)} ${w.vs.toUpperCase()}.` : `Vigilando "${w.match}": te aviso cuando ${w.until === 'start' ? 'empiece' : 'termine'}.`),
+    watchFire: (w, n) => (w.kind === 'price' ? `¡${w.coin} está en ${fmt(n.price)} ${w.vs.toUpperCase()}!${w.text ? ` ${w.text}` : ''}` : `"${w.match}" ${w.until === 'start' ? 'empezó' : 'terminó'}.${w.text ? ` ${w.text}` : ''}`),
     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.',
@@ -52,9 +67,16 @@ const T = {
     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}!`,
+    offload: (k) => `Voy: se lo mandé a mi servidor (${k}). Te cuento cómo va.`,
+    offloadQueued: 'En cola: mi servidor está apagado ahora, empieza cuando vuelva.',
+    offloadStep: (s) => `Sigo en eso: ${s}`,
+    offloadDone: (r) => `Listo: ${r}`,
+    offloadFail: (e) => `Mi servidor no pudo terminarlo: ${e}`,
     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: {
+    watch: (w) => (w.kind === 'price' ? `Vigiando ${w.coin}: te aviso quando estiver ${w.op} ${fmt(w.value)} ${w.vs.toUpperCase()}.` : `Vigiando "${w.match}": te aviso quando ${w.until === 'start' ? 'começar' : 'terminar'}.`),
+    watchFire: (w, n) => (w.kind === 'price' ? `${w.coin} está em ${fmt(n.price)} ${w.vs.toUpperCase()}!${w.text ? ` ${w.text}` : ''}` : `"${w.match}" ${w.until === 'start' ? 'começou' : 'terminou'}.${w.text ? ` ${w.text}` : ''}`),
     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.',
@@ -64,6 +86,11 @@ const T = {
     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}!`,
+    offload: (k) => `Já vou: mandei para o meu servidor (${k}). Te conto como vai.`,
+    offloadQueued: 'Na fila: meu servidor está desligado agora, começa quando voltar.',
+    offloadStep: (s) => `Ainda trabalhando: ${s}`,
+    offloadDone: (r) => `Pronto: ${r}`,
+    offloadFail: (e) => `Meu servidor não conseguiu terminar: ${e}`,
     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.',
   },
 };
@@ -72,13 +99,14 @@ const T = {
 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 (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|setea|alerta|avisa|av[ií]same|cuando|llega|una|pon|dime|est[aá]|hay|para|por favor|d[oó]lares|termine)\\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 fmt = (n) => Number(n).toLocaleString('en-US', { maximumFractionDigits: n < 1 ? 6 : 2 });
 const hhmm = (at) => new Date(at).toTimeString().slice(0, 5);
-const tr = (lang) => T[lang] || T.en;
+export const tr = (lang) => T[lang] || T.en;
 
 // ── local parser ──
 
@@ -177,25 +205,32 @@ export function parseLocal(text, now = Date.now()) {
 
 // ── AI understanding ──
 
-function aiPrompt(text, { lang, notes, reminders, now }) {
+function aiPrompt(text, { lang, notes, reminders, watchers = [], procs = '', more = '', vmKinds = [], 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('; ')}` : '',
+    watchers.length ? `Active watchers: ${watchers.map((w) => (w.kind === 'price' ? `${w.coin} ${w.op} ${w.value} ${w.vs}` : `process "${w.match}" ${w.until}`)).join('; ')}` : '',
+    procs ? `Busiest processes on their computer right now: ${procs}` : '',
     `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"}`,
+    `{"type":"open","url":"https://…"} (open now) · {"type":"note","text":"a durable fact or preference worth remembering"} · {"type":"cancel"} (all pending reminders and watchers) · {"type":"list"}`,
+    `{"type":"watch_price","coin":"bitcoin|ethereum|solana|… (CoinGecko id) or ticker","op":">=|<=","value":N,"vs":"usd|clp|eur|…","text":"what to tell them"} (crypto price alert; checked every minute)`,
+    `{"type":"watch_process","match":"part of the command line, e.g. 'npm run build'","until":"exit|start","text":"what to tell them"} (tell them when a program on their computer finishes or starts)`,
+    vmKinds.length ? `{"type":"offload","kind":"${vmKinds.join('|')}","text":"the full request for your cloud server"} (hand long work to your own server: research = think it through, browse = read the URLs in text, long = multi-step work${vmKinds.includes('code') ? ', code = programming task' : ''}${vmKinds.includes('shell') ? ', shell = one bash command' : ''}; you will report back when it is done)` : '',
+    more,
+    `Use the watch actions for "alert me / let me know if/when …" about a price or a program. Never say you cannot do something these actions can do.`,
     `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'}.`,
+    lang ? `Reply in ${{ es: 'Spanish', pt: 'Portuguese' }[lang] || 'English'}.` : `Reply in the language the human wrote in.`,
   ]
     .filter(Boolean)
     .join('\n');
 }
 
-function parseAi(raw, now) {
+function parseAi(raw, now, extra = null, vmKinds = []) {
   const m = String(raw || '').match(/\{[\s\S]*\}/);
   if (!m) return null;
   let j;
@@ -212,6 +247,13 @@ function parseAi(raw, now) {
     } 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 });
+    else if (a?.type === 'watch_price' && a.coin && Number.isFinite(Number(a.value))) actions.push({ type: 'watch_price', coin: String(a.coin), op: ['<=', '<'].includes(a.op) ? '<=' : '>=', value: Number(a.value), vs: String(a.vs || 'usd').toLowerCase().slice(0, 6), text: String(a.text || '').slice(0, 200) });
+    else if (a?.type === 'watch_process' && a.match) actions.push({ type: 'watch_process', match: String(a.match).slice(0, 120), until: a.until === 'start' ? 'start' : 'exit', text: String(a.text || '').slice(0, 200) });
+    else if (a?.type === 'offload' && vmKinds.includes(a.kind) && a.text) actions.push({ type: 'offload', kind: a.kind, text: String(a.text).slice(0, 8000) });
+    else {
+      const x = extra?.parse(a);
+      if (x) actions.push(x);
+    }
   }
   return { reply: String(j.reply || '').slice(0, 400), actions };
 }
@@ -221,7 +263,7 @@ const safeUrl = (u) => (typeof u === 'string' && /^https?:\/\/[^\s"'<>]+$/i.test
 // ── the assistant ──
 
 /** Desktop notification, best effort. */
-function notify(title, body) {
+export function notify(title, body) {
   const [cmd, args] =
     process.platform === 'darwin'
       ? ['osascript', ['-e', `display notification ${JSON.stringify(body)} with title ${JSON.stringify(title)}`]]
@@ -235,11 +277,45 @@ function notify(title, body) {
 }
 
 /**
- * @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)
+ * @param {{ brain, system: (lang) => string, lang: string, name: string, onFire: (reminder, line) => void, watchers?: object, procs?: () => Promise<string>, access?: () => object, log?: Function }} o
+ *   access()  config.access: memory (keep/use notes), open (open sites), notify (desktop notifications),
+ *             vm + vmKinds (offload to the ot's cloud worker; off unless explicitly true)
+ *   cloud()   the ot id of this computer (signed in to 7ots.com) or null · say(line) speaks later
  */
-export function createAssistant({ brain, system, lang, name, onFire, access = () => ({}), log = () => {} }) {
+export function createAssistant({ brain, system, lang, name, onFire, watchers = null, procs = async () => '', access = () => ({}), extra = null, cloud = () => null, say = () => {}, log = () => {} }) {
   const may = (k) => access()[k] !== false;
+  const vmKinds = () => (access().vm === true && cloud() ? (access().vmKinds || []).filter(Boolean) : []);
+  let offloading = null;
+
+  // Runs in the background: the reply already said "on it"; progress and result come as `say`.
+  async function offload(a, L0) {
+    const otsId = cloud();
+    let last = 0;
+    const speak = (line, force = false) => {
+      if (!force && Date.now() - last < 20000) return;
+      last = Date.now();
+      say(line);
+    };
+    try {
+      const context = may('memory') && notes.length ? `What the owner told the pet to remember:\n${notes.slice(-15).map((n) => `- ${n.text}`).join('\n')}` : '';
+      const job = await submitJob(otsId, { kind: a.kind, input: a.text, context });
+      offloading = job.id;
+      last = Date.now();
+      if (!job.online) speak(L0.offloadQueued, true);
+      const end = await followJob(otsId, job.id, { onEvent: (ev) => ev.kind === 'progress' && !/^start /.test(ev.text) && speak(L0.offloadStep(String(ev.text).slice(0, 160))) });
+      if (end.status === 'completed') {
+        const text = String(end.result || '').trim();
+        if (may('memory')) (notes.push({ text: `[${a.kind}] ${a.text.slice(0, 80)} → ${text.slice(0, 200)}`, at: Date.now() }), saveN());
+        if (may('notify')) notify(`${name} · 7ots`, text.slice(0, 200));
+        speak(L0.offloadDone(text.length > 300 ? `${text.slice(0, 300)}…` : text), true);
+      } else if (end.status !== 'cancelled') speak(L0.offloadFail(end.error || end.status), true);
+    } catch (e) {
+      log(`offload: ${e.message}`);
+      speak(L0.offloadFail(e.message), true);
+    } finally {
+      offloading = null;
+    }
+  }
   let L = tr(lang);
   const remF = homeFile('reminders.json');
   const memF = homeFile('memory.json');
@@ -289,8 +365,16 @@ export function createAssistant({ brain, system, lang, name, onFire, access = ()
         const n = reminders.length;
         reminders = [];
         saveR();
+        watchers?.cancel('all');
         out.push(L.cancelled(n));
-      } else if (a.type === 'list') out.push(reminders.length ? L.list(reminders) : L.none);
+      } else if (a.type === 'watch_price' || a.type === 'watch_process') {
+        const w = watchers && (a.type === 'watch_price' ? watchers.addPrice(a) : watchers.addProcess(a));
+        if (w) (w.lang = L === T.es ? 'es' : L === T.pt ? 'pt' : 'en'), out.push(L.watch(w));
+      } else if (a.type === 'offload') {
+        if (!vmKinds().includes(a.kind)) continue;
+        offload(a, L);
+        out.push(L.offload(a.kind));
+      } else if (a.type === 'list') out.push(reminders.length ? L.list(reminders) : L.none, ...(watchers?.list || []).map((w) => L.watch(w)));
       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);
@@ -305,24 +389,46 @@ export function createAssistant({ brain, system, lang, name, onFire, access = ()
     get notes() {
       return notes.slice();
     },
+    /** The cloud job running now (vmj_…) or null. */
+    get offloading() {
+      return offloading;
+    },
     /** Free text → { reply, actions }. Never throws. */
     async ask(text) {
       const now = Date.now();
-      const said = langOf(text) || lang;
+      const detected = langOf(text);
+      const said = detected || 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);
+          const raw = await brain.think({ purpose: 'assistant', system: system(detected), messages: [{ role: 'user', content: aiPrompt(text, { lang: detected, notes: may('memory') ? notes.slice(-30) : [], reminders, watchers: watchers?.list || [], procs: may('processes') ? await procs().catch(() => '') : '', more: extra?.prompt() || '', vmKinds: vmKinds(), now }) }], timeoutMs: 45000, raw: true });
+          ai = parseAi(raw, now, extra, vmKinds());
         } 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 };
+        // fetched things (logs, email, agents…): the brain reads them and answers once more
+        const fetched = [];
+        for (const a of ai.actions.filter((x) => x.extra).slice(0, 3)) {
+          const r = await extra.run(a, detected || lang);
+          if (r.data) fetched.push(r.data);
+        }
+        if (fetched.length) {
+          let said = '';
+          try {
+            said = await brain.think({ purpose: 'assistant', system: system(detected), messages: [{ role: 'user', content: `Your human wrote to you: «${String(text).slice(0, 800)}»\nHere is what you fetched for them:\n${fetched.join('\n\n').slice(0, 9000)}\n\nNow answer them in 1-3 short sentences, in character, no JSON, no markdown. Never quote secrets.` }], timeoutMs: 45000 });
+          } catch (e) {
+            log(`assistant: ${e.message}`);
+          }
+          return { reply: [ai.reply, said].filter(Boolean).join(' ') || done.join(' ') || L.help, actions: ai.actions };
+        }
+        // a watch the AI asked for but that could not be set (unknown coin…): say so instead of a cheerful reply
+        const failed = ai.actions.some((a) => a.type.startsWith('watch_')) && !done.length;
+        return { reply: failed ? L.help : ai.reply || done.join(' ') || L.help, actions: ai.actions };
       }
       const done = run(local);
       return { reply: done.join(' ') || L.help, actions: local };

package/cli/lib/brain.mjs

@@ -2,6 +2,7 @@
  * The pet's brain. It turns "what just happened" into one short line in the ot's voice.
  *
  *   cli     the user's own AI CLI, as a separate instance: claude -p · codex exec · gemini -p · ollama run
+ *           · orquesta -p (Orquesta CLI; model = an endpoint name, e.g. "batuta")
  *           (runs in ~/.7ots with SEVENOTS_PET_BRAIN=1 so our hooks don't fire inside it)
  *   api     own key (Anthropic or any OpenAI-compatible endpoint) through server/llm.mjs
  *   batuta  Orquesta's Batuta LLM (OpenAI-compatible) with ORQUESTA_TOKEN
@@ -12,14 +13,16 @@
 import { spawn, spawnSync } from 'node:child_process';
 import { identityPrompt } from '../../src/identity/schema.js';
 import { createLLM } from '../../server/llm.mjs';
-import { env, ORQUESTA_URL } from './config.mjs';
+import { env, loadConfig, ORQUESTA_URL } from './config.mjs';
+import { characterPrompt, integrationsPrompt } from './integrations.mjs';
 import { ensureHome, PET_PORT } from './paths.mjs';
 
 export const AI_CLIS = {
-  claude: { bin: 'claude', args: (p, m) => ['-p', p, ...(m ? ['--model', m] : [])] },
+  claude: { bin: 'claude', json: true, args: (p, m, files) => ['-p', p, '--output-format', 'json', ...(m ? ['--model', m] : []), ...(files ? ['--allowedTools', 'Read'] : [])], vision: true },
   codex: { bin: 'codex', args: (p, m) => ['exec', '--skip-git-repo-check', ...(m ? ['-m', m] : []), p] },
   gemini: { bin: 'gemini', args: (p, m) => ['-p', p, ...(m ? ['-m', m] : [])] },
   ollama: { bin: 'ollama', args: (p, m) => ['run', m || 'llama3.2', p] },
+  orquesta: { bin: 'orquesta', args: (p, m) => ['-p', p, ...(m ? ['--endpoint', m] : [])] },
 };
 
 const LANG_NAME = { en: 'English', es: 'Spanish', pt: 'Portuguese' };
@@ -38,18 +41,27 @@ export function petSystem(identity, { lang, role = 'pet' } = {}) {
   const base = identityPrompt(identity, 'en');
   const job =
     role === 'assistant'
-      ? `You live on your human's computer as a virtual pet and also their small daily assistant: reminders, opening sites, remembering what matters about their work.`
+      ? `You live on your human's computer as a virtual pet and also their small daily assistant: reminders, alerts (prices, programs that finish), opening sites, remembering what matters about their work.`
       : role === 'meet'
       ? `You are in a live video call (apuchat meet). Your words are spoken aloud: answer in 1-3 short sentences, no markdown, no emojis, no lists.`
       : `You live on your human's computer as a virtual pet (a tamagotchi). You watch their terminal and their coding agent and comment on it. Answer with ONE short line (max 18 words), in character, no quotes, no markdown. Be playful, never rude, never repeat yourself.`;
-  return `${base}\n${job}\nAlways answer in ${L}.`;
+  // the character sheet (settings → Personality) weighs more than the identity's traits;
+  // integrations (settings → Permissions) tell the assistant what else it can reach
+  let config = {};
+  try {
+    config = loadConfig();
+  } catch {}
+  const sheet = characterPrompt(config.character);
+  const tools = role === 'assistant' ? integrationsPrompt(config) : '';
+  // 'auto': the language the human just wrote in (they may switch from the ot's usual one)
+  return `${base}${sheet ? `\n${sheet}` : ''}\n${job}${tools ? `\n${tools}` : ''}\n${lang === 'auto' ? 'Always answer in the language your human writes in.' : `Always answer in ${L}.`}`;
 }
 
-function runCli({ cli, model, command }, prompt, timeoutMs) {
+function runCli({ cli, model, command }, prompt, timeoutMs, files) {
   const spec = cli === 'custom' ? { bin: '/bin/sh', args: (p) => ['-c', command, 'sh', p] } : AI_CLIS[cli];
   if (!spec) return Promise.reject(new Error(`unknown cli ${cli}`));
   return new Promise((resolve, reject) => {
-    const child = spawn(spec.bin, spec.args(prompt, model), {
+    const child = spawn(spec.bin, spec.args(prompt, model, files), {
       cwd: ensureHome(),
       env: { ...process.env, SEVENOTS_PET_BRAIN: '1', NO_COLOR: '1' },
       stdio: ['ignore', 'pipe', 'ignore'],
@@ -66,7 +78,17 @@ function runCli({ cli, model, command }, prompt, timeoutMs) {
     });
     child.on('close', (code) => {
       clearTimeout(timer);
-      code === 0 && out.trim() ? resolve(out) : reject(new Error(`exit ${code}`));
+      if (code !== 0 || !out.trim()) return reject(new Error(`exit ${code}`));
+      if (!spec.json) return resolve({ text: out });
+      // claude --output-format json: the reply plus what it cost (tokens, USD)
+      try {
+        const j = JSON.parse(out);
+        const u = j.usage || {};
+        if (j.is_error) return reject(new Error(String(j.result || 'error').slice(0, 200)));
+        resolve({ text: String(j.result ?? ''), usage: { in: u.input_tokens || 0, out: u.output_tokens || 0, cacheRead: u.cache_read_input_tokens || 0, cacheWrite: u.cache_creation_input_tokens || 0, usd: j.total_cost_usd } });
+      } catch {
+        resolve({ text: out });
+      }
     });
   });
 }
@@ -92,9 +114,15 @@ export function createBrain(brain = { kind: 'lines' }, home = {}) {
   if (brain.kind === 'cli') {
     return {
       kind: 'cli',
-      async think({ system, messages, timeoutMs = 45000, raw = false }) {
+      // files: images to look at (the screen); only CLIs that can read them (claude) get them
+      vision: Boolean(AI_CLIS[brain.cli]?.vision),
+      async think({ system, messages, timeoutMs = 45000, raw = false, files = null, onUsage }) {
         const convo = messages.map((m) => `${m.role === 'user' ? 'Them' : 'You'}: ${m.content}`).join('\n');
-        const out = await runCli(brain, `${system}\n\n${convo}\nYou:`, timeoutMs);
+        const look = files?.length ? `\n\n(Use the Read tool to look at: ${files.join(', ')})` : '';
+        const prompt = `${system}${look}\n\n${convo}\nYou:`;
+        const { text: out, usage } = await runCli(brain, prompt, timeoutMs, files?.length ? files : null);
+        // CLIs that don't report usage: a rough count (≈ 4 characters a token)
+        onUsage?.(usage || { in: Math.round(prompt.length / 4), out: Math.round(out.length / 4), approx: true });
         return raw ? out : cleanReply(out);
       },
     };
@@ -115,8 +143,9 @@ export function createBrain(brain = { kind: 'lines' }, home = {}) {
     const llm = createLLM(llmEnv);
     return {
       kind: brain.kind,
-      async think({ system, messages, raw = false }) {
+      async think({ system, messages, raw = false, onUsage }) {
         const r = await llm.step({ system, messages, tools: [] });
+        if (r.usage) onUsage?.(r.usage);
         return raw ? r.text : cleanReply(r.text);
       },
     };
@@ -125,7 +154,7 @@ export function createBrain(brain = { kind: 'lines' }, home = {}) {
     const url = `${home.url.replace(/\/+$/, '')}/chat`;
     return {
       kind: '7ots',
-      async think({ system, messages, timeoutMs = 45000, raw = false }) {
+      async think({ system, messages, timeoutMs = 45000, raw = false, onUsage }) {
         // The ot's home only serves its own domains: add http://127.0.0.1:<port> to them in /app/.
         const res = await fetch(url, {
           method: 'POST',
@@ -135,6 +164,7 @@ export function createBrain(brain = { kind: 'lines' }, home = {}) {
         });
         const data = await res.json().catch(() => ({}));
         if (!res.ok) throw new Error(data.error || `HTTP ${res.status}`);
+        if (data.usage) onUsage?.(data.usage);
         return raw ? data.text : cleanReply(data.text);
       },
     };