@7ots/cli 0.1.6 → 0.1.8

package/README.md

@@ -10,7 +10,7 @@ npx @7ots/cli hooks install --claude # y escucha a Claude Code (aciertos, errore
 ```
 
 - **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.
+- **Cuida a tu agente de código.** Hooks de Claude Code y de la shell (bash/zsh): te avisa cuando tu agente termina, falla o te pide permiso, y cuando un comando falla.
 - **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
@@ -232,7 +232,7 @@ El proxy sirve un panel en **`/backoffice/`** (por ejemplo `http://localhost:878
 | Comportamiento | Proactividad (nivel, saludo, límites, señales), modo compañero, puntero, acciones y micrófono. |
 | Widget y marca | Lado, redondeo, tipografía, color, y JSON avanzado de `init()`. |
 | Privacidad y navegación | `privateSelectors`, `ignoreSelectors` y `navigation.allowedOrigins`. |
-| Servidor y claves | Todas las variables del proxy: LLM, TTS, apumail/apuchat, límites, orígenes… |
+| Avanzado (servidor y claves) | Todas las variables del proxy: LLM, TTS, apumail/apuchat, límites, orígenes… |
 | Instalar | El snippet de una línea (`embed.js`) y los de código, tarjeta y editor. |
 
 - **Vista previa en vivo**: los cambios sin guardar se ven al momento en un widget de prueba.
@@ -630,7 +630,7 @@ src/
   character/Character.js     personaje 2D estilo Pou: render, animación, ánimos y gestos
   character/parts.js         catálogo: formas, ojos, bocas, cejas, accesorios, estilos
   character/AvatarEditor.js  <ots-avatar-editor>: editor visual del personaje (y 3D/retrato)
-backoffice/                panel /backoffice/: index.html, app.js, app.css, preview.html
+backoffice/                panel /backoffice/: index.html, app.js, app.css
 server/                    proxy Node (sin frameworks): llm, tts, contact, demo
   identity.mjs             identidad vigente: entorno + data/identity.json
   settings.mjs             data/config.json (widget + servidor) y data/secrets.json sobre el entorno

package/cli/7ots.mjs

@@ -178,6 +178,18 @@ function ensureElectron() {
 }
 
 /** Electron window (detached). Resolves ok once it has stayed up for a few seconds. */
+
+// The shell's menus speak the human's language (like the settings page): SEVENOTS_LANG, config.lang, the
+// system's, and only then the ot's — cliLang() puts the ot's first, which left a Spanish desktop with English menus.
+function menuLang() {
+  const pick = (v) => (['en', 'es', 'pt'].includes(v) ? v : '');
+  let lang = '';
+  try {
+    lang = loadConfig().lang;
+  } catch {}
+  return pick(process.env.SEVENOTS_LANG) || pick(lang) || pick(String(process.env.LC_ALL || process.env.LC_MESSAGES || process.env.LANG || '').slice(0, 2).toLowerCase()) || cliLang();
+}
+
 function openDesktop({ opaque = false, view3d = false } = {}) {
   console.log(dim(t('pet.electron')));
   const { bin, error } = ensureElectron();
@@ -186,7 +198,7 @@ function openDesktop({ opaque = false, view3d = false } = {}) {
   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(), SEVENOTS_PET_OPAQUE: opaque ? '1' : '', SEVENOTS_PET_3D: view3d ? '1' : '', SEVENOTS_PET_LANG: cliLang() },
+    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: menuLang() },
   });
   return new Promise((resolve) => {
     const timer = setTimeout(() => {

package/cli/lib/account.mjs

@@ -10,12 +10,15 @@
  *   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
+ *   sync()     keeps this pet and its ot on 7ots.com equal (look and mods, personality, character
+ *              sheet): whichever side changed since the last sync wins; both → the newer one
  */
 
 import { hostname } from 'node:os';
-import { copyFileSync, existsSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+import { copyFileSync, existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
 import { env, loadConfig, saveConfig, saveKey } from './config.mjs';
-import { homeFile, writeJson } from './paths.mjs';
+import { homeFile, readJson, writeJson } from './paths.mjs';
 import { defineIdentity } from '../../src/identity/schema.js';
 
 export const SEVENOTS_URL = (process.env.SEVENOTS_URL || 'https://7ots.com').replace(/\/+$/, '');
@@ -87,3 +90,150 @@ export async function logout() {
   delete config.account;
   saveConfig(config);
 }
+
+// ── sync: the same ot here and on 7ots.com ──
+const SYNCED = ['name', 'role', 'tagline', 'bio', 'language', 'languages'];
+const SHEET = ['backstory', 'style', 'quirks', 'scenario', 'greeting', 'examples'];
+const MODEL = /^\/mods\/([a-f0-9]{16})\.(glb|vrm)$/;
+const hashOf = (v) => createHash('sha256').update(JSON.stringify(v)).digest('hex').slice(0, 16);
+
+/** The part of an identity both sides keep equal. */
+function syncView(identity) {
+  const id = defineIdentity(identity);
+  const { tone, traits, sheet } = id.personality;
+  return { ...Object.fromEntries(SYNCED.map((k) => [k, id[k]])), personality: { tone, traits, sheet }, look: { character: id.look.character } };
+}
+/** This pet's side: identity.json + the character sheet (kept in config.character). */
+function localView() {
+  const raw = readJson(homeFile('identity.json')) || {};
+  const ch = loadConfig().character || {};
+  return syncView({ ...raw, personality: { ...raw.personality, sheet: Object.fromEntries(SHEET.filter((k) => ch[k]).map((k) => [k, ch[k]])) } });
+}
+const modelsOf = (view) => (view.look.character.mods || []).map((m) => m.model?.url).filter((u) => MODEL.test(u || ''));
+const localMtime = () => Math.max(...['identity.json', 'config.json'].map((f) => (existsSync(homeFile(f)) ? statSync(homeFile(f)).mtimeMs : 0)));
+
+async function pushModels(view) {
+  const token = env().SEVENOTS_TOKEN;
+  for (const url of modelsOf(view)) {
+    const file = homeFile(url.slice(1));
+    if (!existsSync(file)) continue;
+    const head = await fetch(`${SEVENOTS_URL}${url}`, { method: 'HEAD', signal: AbortSignal.timeout(15000) }).catch(() => null);
+    if (head?.ok) continue;
+    const [, , ext] = MODEL.exec(url);
+    const r = await fetch(`${SEVENOTS_URL}/api/device/ots/${encodeURIComponent(loadConfig().account.otsId)}/files?ext=${ext}`, { method: 'POST', headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/octet-stream' }, body: readFileSync(file), signal: AbortSignal.timeout(120000) });
+    if (!r.ok) throw new Error(`model upload: HTTP ${r.status}`);
+  }
+}
+async function pullModels(view) {
+  for (const url of modelsOf(view)) {
+    const file = homeFile(url.slice(1));
+    if (existsSync(file)) continue;
+    const r = await fetch(`${SEVENOTS_URL}${url}`, { signal: AbortSignal.timeout(120000) });
+    if (!r.ok) continue;
+    const buf = Buffer.from(await r.arrayBuffer());
+    // content-addressed: only keep it if it is what its name says
+    if (buf.toString('latin1', 0, 4) !== 'glTF' || createHash('sha256').update(buf).digest('hex').slice(0, 16) !== MODEL.exec(url)[1]) continue;
+    mkdirSync(homeFile('mods'), { recursive: true });
+    writeFileSync(file, buf);
+  }
+}
+
+/** @returns {Promise<{action: 'off'|'same'|'push'|'pull'}>} */
+export async function sync() {
+  const otsId = loadConfig().account?.otsId;
+  if (!signedIn() || !otsId) return { action: 'off' };
+  let state = readJson(homeFile('sync.json')) || {};
+  if (state.otsId !== otsId) state = { otsId };
+  const remote = await pull(otsId);
+  const cloud = syncView(remote.identity);
+  const local = localView();
+  const hc = hashOf(cloud);
+  const hl = hashOf(local);
+  const done = (action, extra = {}) => (writeJson(homeFile('sync.json'), { ...state, at: Date.now(), ...extra }), { action });
+  if (hc === hl) return done('same', { local: hl, cloud: hc });
+  const localChanged = hl !== state.local;
+  const cloudChanged = hc !== state.cloud;
+  if (!localChanged && !cloudChanged) return done('same'); // they differ only in how each side writes it
+  const push = localChanged && cloudChanged ? localMtime() > (remote.updatedAt || 0) : localChanged;
+  if (push) {
+    await pushModels(local);
+    const r = await api(`/ots/${encodeURIComponent(otsId)}/identity`, { method: 'PUT', body: { identity: local } });
+    return done('push', { local: hl, cloud: hashOf(syncView(r.identity)) });
+  }
+  await pullModels(cloud);
+  const file = homeFile('identity.json');
+  const raw = readJson(file) || {};
+  const { sheet = {}, ...personality } = cloud.personality;
+  writeJson(file, { ...raw, ...Object.fromEntries(SYNCED.map((k) => [k, cloud[k]])), personality: { ...raw.personality, ...personality }, look: { ...raw.look, character: cloud.look.character } });
+  const config = loadConfig();
+  config.character = { ...config.character, ...Object.fromEntries(SHEET.map((k) => [k, sheet[k] || ''])) };
+  saveConfig(config);
+  return done('pull', { local: hashOf(localView()), cloud: hc });
+}
+
+// ── community mods (server/platform/mods.mjs) ──
+const MAX_SHARE = 20 * 1024 * 1024;
+
+/** Downloads a mod's /mods/<hash> models into ~/.7ots/mods (checked against their hash). */
+async function fetchModels(mod) {
+  const urls = [mod.model?.url].filter((u) => MODEL.test(u || ''));
+  for (const url of urls) {
+    const file = homeFile(url.slice(1));
+    if (existsSync(file)) continue;
+    const r = await fetch(`${SEVENOTS_URL}${url}`, { signal: AbortSignal.timeout(180000) });
+    if (!r.ok) throw Object.assign(new Error(`model: HTTP ${r.status}`), { status: 502 });
+    const buf = Buffer.from(await r.arrayBuffer());
+    if (buf.toString('latin1', 0, 4) !== 'glTF' || createHash('sha256').update(buf).digest('hex').slice(0, 16) !== MODEL.exec(url)[1]) throw Object.assign(new Error('model: bad file'), { status: 502 });
+    mkdirSync(homeFile('mods'), { recursive: true });
+    writeFileSync(file, buf);
+  }
+}
+
+/** A data: glb (≤ 1.5 MB, inline in the mod) becomes a /mods/<hash> file here, so it can be shared as one. */
+function inlineToFile(url) {
+  const m = /^data:model\/gltf-binary;base64,(.+)$/.exec(url || '');
+  if (!m) return url;
+  const buf = Buffer.from(m[1], 'base64');
+  const name = `${createHash('sha256').update(buf).digest('hex').slice(0, 16)}.glb`;
+  mkdirSync(homeFile('mods'), { recursive: true });
+  if (!existsSync(homeFile(`mods/${name}`))) writeFileSync(homeFile(`mods/${name}`), buf);
+  return `/mods/${name}`;
+}
+
+export const community = {
+  async list({ sort = 'top', q = '' } = {}) {
+    const qs = `?sort=${encodeURIComponent(sort)}&q=${encodeURIComponent(q)}`;
+    if (signedIn()) return api(`/mods${qs}`);
+    const r = await fetch(`${SEVENOTS_URL}/api/mods${qs}`, { signal: AbortSignal.timeout(15000) });
+    if (!r.ok) throw Object.assign(new Error(`HTTP ${r.status}`), { status: r.status });
+    return r.json();
+  },
+  mine: () => api('/mods/mine'),
+  /** Counts the install (signed in), downloads its models and returns the mod to wear. */
+  async install(id) {
+    const { mod } = signedIn()
+      ? await api(`/mods/${encodeURIComponent(id)}/install`, { method: 'POST', body: {} })
+      : await (await fetch(`${SEVENOTS_URL}/api/mods/${encodeURIComponent(id)}`, { signal: AbortSignal.timeout(15000) })).json();
+    if (!mod?.mod) throw Object.assign(new Error('not found'), { status: 404 });
+    await fetchModels(mod.mod);
+    return mod.mod;
+  },
+  rate: (id, stars) => api(`/mods/${encodeURIComponent(id)}/rate`, { method: 'POST', body: { stars } }),
+  report: (id, reason) => api(`/mods/${encodeURIComponent(id)}/report`, { method: 'POST', body: { reason } }),
+  remove: (id) => api(`/mods/${encodeURIComponent(id)}`, { method: 'DELETE' }),
+  /** Publishes a mod of this pet: first its models (as /mods/<hash> files on 7ots.com), then the mod. */
+  async share(mod) {
+    const out = { ...mod, ...(mod.model ? { model: { ...mod.model, url: inlineToFile(mod.model.url) } } : {}) };
+    const token = env().SEVENOTS_TOKEN;
+    for (const url of [out.model?.url].filter((u) => MODEL.test(u || ''))) {
+      const head = await fetch(`${SEVENOTS_URL}${url}`, { method: 'HEAD', signal: AbortSignal.timeout(15000) }).catch(() => null);
+      if (head?.ok) continue;
+      const file = homeFile(url.slice(1));
+      if (!existsSync(file)) throw Object.assign(new Error('model missing here'), { status: 404 });
+      if (statSync(file).size > MAX_SHARE) throw Object.assign(new Error('max 20 MB'), { status: 413 });
+      const r = await fetch(`${SEVENOTS_URL}/api/device/mods/files?ext=${MODEL.exec(url)[2]}`, { method: 'POST', headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/octet-stream' }, body: readFileSync(file), signal: AbortSignal.timeout(180000) });
+      if (!r.ok) throw Object.assign(new Error(`model upload: HTTP ${r.status}`), { status: r.status });
+    }
+    return api('/mods', { method: 'POST', body: { mod: out } });
+  },
+};

package/cli/lib/assistant.mjs

@@ -15,6 +15,7 @@
  * 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.
+ * `sites` (prowl.mjs, access.sites): Prowl.world usage guides for the domains in play, as untrusted reference.
  */
 
 import { spawn } from 'node:child_process';
@@ -282,7 +283,7 @@ export function notify(title, body) {
  *             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, watchers = null, procs = async () => '', access = () => ({}), extra = null, cloud = () => null, say = () => {}, log = () => {} }) {
+export function createAssistant({ brain, system, lang, name, onFire, watchers = null, procs = async () => '', access = () => ({}), memoryTokens = () => 20000, extra = null, sites = null, cloud = () => null, say = () => {}, log = () => {} }) {
   const may = (k) => access()[k] !== false;
   const vmKinds = () => (access().vm === true && cloud() ? (access().vmKinds || []).filter(Boolean) : []);
   let offloading = null;
@@ -324,6 +325,55 @@ export function createAssistant({ brain, system, lang, name, onFire, watchers =
   const saveR = () => writeJson(remF, reminders);
   const saveN = () => writeJson(memF, notes.slice(-200));
 
+  // Conversation memory: recent turns verbatim, older ones folded into a summary once past the token budget.
+  const convF = homeFile('conversation.json');
+  let conv = readJson(convF, null) || {};
+  conv = { summary: String(conv.summary || ''), turns: Array.isArray(conv.turns) ? conv.turns : [] };
+  const saveC = () => writeJson(convF, conv);
+  const tokensOf = (s) => Math.ceil(String(s).length / 4);
+  const convTokens = () => tokensOf(conv.summary) + conv.turns.reduce((n, t) => n + tokensOf(t.u) + tokensOf(t.a), 0);
+  let compacting = null;
+  function convBlock() {
+    if (!(memoryTokens() > 0) || (!conv.summary && !conv.turns.length)) return '';
+    const lines = conv.turns.map((t) => `Them: ${t.u}\nYou: ${t.a}`).join('\n');
+    return `Your conversation with them so far (context for follow-ups; do not repeat old answers):\n${conv.summary ? `[earlier, summarized] ${conv.summary}\n` : ''}${lines}`;
+  }
+  async function compact() {
+    const budget = memoryTokens();
+    if (!(budget > 0) || convTokens() <= budget || compacting) return;
+    // fold the oldest half (at least until it fits in ~70% of the budget) into the summary
+    let cut = Math.max(1, Math.floor(conv.turns.length / 2));
+    const keep = () => tokensOf(conv.summary) + conv.turns.slice(cut).reduce((n, t) => n + tokensOf(t.u) + tokensOf(t.a), 0);
+    while (cut < conv.turns.length - 1 && keep() > budget * 0.7) cut++;
+    const old = conv.turns.slice(0, cut);
+    const room = Math.max(300, Math.floor(budget * 0.25)) * 4;
+    compacting = (async () => {
+      let summary = '';
+      if (brain.kind !== 'lines') {
+        try {
+          const text = old.map((t) => `Them: ${t.u}\nYou: ${t.a}`).join('\n').slice(-room * 6);
+          summary = await brain.think({ purpose: 'compact', system: 'You compress chat history for a desktop pet assistant.', messages: [{ role: 'user', content: `Summary so far: ${conv.summary || '(none)'}\n\nNew turns:\n${text}\n\nWrite one updated summary (plain text, under ${Math.floor(room / 4)} tokens) keeping facts, decisions, open requests and the owner's preferences. No secrets.` }], timeoutMs: 60000 });
+        } catch (e) {
+          log(`compact: ${e.message}`);
+        }
+      }
+      // brain off or failed: keep the gist of what they asked
+      if (!summary) summary = [conv.summary, ...old.map((t) => t.u.slice(0, 120))].filter(Boolean).join(' · ');
+      conv.summary = String(summary).trim().slice(-room);
+      conv.turns = conv.turns.slice(old.length);
+      saveC();
+    })().finally(() => {
+      compacting = null;
+    });
+    return compacting;
+  }
+  function remember(u, a) {
+    if (!(memoryTokens() > 0) || !a) return;
+    conv.turns.push({ u: String(u).slice(0, 4000), a: String(a).slice(0, 4000), at: Date.now() });
+    saveC();
+    compact().catch(() => {});
+  }
+
   function fire(r) {
     r.done = true;
     const line = tr(r.lang || lang).fire(r);
@@ -382,6 +432,50 @@ export function createAssistant({ brain, system, lang, name, onFire, watchers =
     return out;
   }
 
+  /** Free text → { reply, actions }. Never throws. */
+  async function answer(text) {
+    const now = Date.now();
+    const detected = langOf(text);
+    const said = detected || lang;
+    L = tr(said);
+    const local = parseLocal(text, now);
+    let ai = null;
+    if (brain.kind !== 'lines') {
+      try {
+        // Prowl.world guides for the sites in play (access.sites; untrusted reference), fetched alongside the processes
+        const [running, siteRef] = await Promise.all([may('processes') ? procs().catch(() => '') : '', sites ? sites.prompt(text).catch(() => '') : '']);
+        const more = [extra?.prompt() || '', siteRef, convBlock()].filter(Boolean).join('\n');
+        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: running, more, 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);
+      // 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: `${convBlock() ? `${convBlock()}\n\n` : ''}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 };
+  }
+
   return {
     get reminders() {
       return reminders.slice();
@@ -395,43 +489,18 @@ export function createAssistant({ brain, system, lang, name, onFire, watchers =
     },
     /** Free text → { reply, actions }. Never throws. */
     async ask(text) {
-      const now = Date.now();
-      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({ 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);
-        // 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 };
+      const r = await answer(text);
+      remember(text, r.reply);
+      return r;
+    },
+    /** What it remembers of the conversation: { tokens, budget, summary, turns }. */
+    get conversation() {
+      return { tokens: convTokens(), budget: memoryTokens(), summary: conv.summary, turns: conv.turns.slice() };
+    },
+    forgetConversation() {
+      conv = { summary: '', turns: [] };
+      saveC();
+      return true;
     },
     /** Forget one note (by its timestamp, stable across the list) or all of them. */
     forget(at) {

package/cli/lib/brain.mjs

@@ -11,14 +11,25 @@
  */
 
 import { spawn, spawnSync } from 'node:child_process';
+import { homedir } from 'node:os';
+import { delimiter, dirname, join } from 'node:path';
 import { identityPrompt } from '../../src/identity/schema.js';
 import { createLLM } from '../../server/llm.mjs';
 import { env, loadConfig, ORQUESTA_URL } from './config.mjs';
 import { characterPrompt, integrationsPrompt } from './integrations.mjs';
 import { ensureHome, PET_PORT } from './paths.mjs';
 
+// Started from a desktop launcher or autostart, the daemon gets a bare PATH (/usr/bin:/bin) and can't find
+// CLIs installed per user (claude lives in ~/.local/bin): add the usual places before looking for them.
+{
+  const home = homedir();
+  const extra = [join(home, '.local', 'bin'), join(home, '.npm-global', 'bin'), join(home, '.bun', 'bin'), join(home, '.cargo', 'bin'), join(home, '.volta', 'bin'), dirname(process.execPath), '/usr/local/bin', '/opt/homebrew/bin', '/snap/bin'];
+  const have = (process.env.PATH || '').split(delimiter).filter(Boolean);
+  process.env.PATH = [...have, ...extra.filter((d) => !have.includes(d))].join(delimiter);
+}
+
 export const AI_CLIS = {
-  claude: { bin: 'claude', json: true, args: (p, m, files) => ['-p', p, '--output-format', 'json', ...(m ? ['--model', m] : []), ...(files ? ['--allowedTools', 'Read'] : [])], vision: true },
+  claude: { bin: 'claude', json: true, args: (p, m, files) => ['-p', p, '--output-format', 'json', ...(m ? ['--model', m] : []), ...(files ? ['--allowedTools', 'Read'] : [])], vision: true, minTimeoutMs: 120000 }, // claude -p can take ~30 s just to start (hooks, plugins, MCP servers)
   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] },
@@ -70,7 +81,7 @@ function runCli({ cli, model, command }, prompt, timeoutMs, files) {
     const timer = setTimeout(() => {
       child.kill('SIGTERM');
       reject(new Error('timeout'));
-    }, timeoutMs);
+    }, Math.max(timeoutMs, spec.minTimeoutMs || 0));
     child.stdout.on('data', (d) => (out += d).length > 20000 && child.kill('SIGTERM'));
     child.on('error', (e) => {
       clearTimeout(timer);

package/cli/lib/config.mjs

@@ -19,6 +19,7 @@
  *            memory: true,  it keeps notes about you and uses them when answering
  *            open: true,    it may open sites in your browser (reminders, "open my mail")
  *            notify: true,  desktop notifications when a reminder fires
+ *            sites: true,   for sites you mention, it reads their usage guide on Prowl.world (only the domain is sent; prowl.mjs)
  *            screen: false, it looks at the active window and, every screen.every minutes, a screenshot (screen.mjs)
  *            processes: false, it sees which programs run (name, cpu, memory) and can wait for one to finish
  *            logs: false,   it may read the logs of running processes (journal, pm2, docker, a log file) when asked
@@ -48,8 +49,10 @@ export const CONFIG_DEFAULTS = Object.freeze({
   brain: { kind: 'lines' },
   voice: { kind: 'browser' },
   pet: { mode: 'ask', annoy: 2 },
-  access: { agent: true, memory: true, open: true, notify: true, screen: false, processes: false, logs: false, inbox: false, vm: false, vmKinds: ['research', 'browse', 'long'] },
+  access: { agent: true, memory: true, open: true, notify: true, sites: true, screen: false, processes: false, logs: false, inbox: false, vm: false, vmKinds: ['research', 'browse', 'long'] },
   screen: { every: 5 },
+  // conversation memory: recent turns up to `tokens` (≈chars/4), older ones compacted into a summary; 0 = off
+  memory: { tokens: 20000 },
   integrations: { orquesta: { on: false }, apumail: { on: false, inbox: '' }, custom: [] },
   character: {},
 });
@@ -65,6 +68,7 @@ export function loadConfig() {
     pet: { ...CONFIG_DEFAULTS.pet, ...c.pet },
     access: { ...CONFIG_DEFAULTS.access, ...c.access },
     screen: { ...CONFIG_DEFAULTS.screen, ...c.screen },
+    memory: { ...CONFIG_DEFAULTS.memory, ...c.memory },
     integrations: {
       orquesta: { ...CONFIG_DEFAULTS.integrations.orquesta, ...c.integrations?.orquesta },
       apumail: { ...CONFIG_DEFAULTS.integrations.apumail, ...c.integrations?.apumail },

package/cli/lib/inferences.mjs

@@ -3,20 +3,44 @@
  * the data it used) and what came back. Kept in ~/.7ots/inferences.jsonl (0600, last 300) and shown on /settings.
  */
 
-import { appendFileSync, existsSync, readFileSync, writeFileSync, chmodSync } from 'node:fs';
-import { homeFile } from './paths.mjs';
+import { appendFileSync, existsSync, readFileSync, readdirSync, writeFileSync, chmodSync } from 'node:fs';
+import { basename, dirname, join } from 'node:path';
+import { HOME, homeFile, readJson } from './paths.mjs';
 
 const MAX = 300;
 const FILE = () => homeFile('inferences.jsonl');
 const cut = (s, n) => (String(s ?? '').length > n ? `${String(s).slice(0, n)}…` : String(s ?? ''));
 
-export function createInferenceLog() {
-  let rows = [];
+const readRows = (file) => {
   try {
-    if (existsSync(FILE())) rows = readFileSync(FILE(), 'utf8').trim().split('\n').filter(Boolean).slice(-MAX).map((l) => JSON.parse(l));
+    return existsSync(file) ? readFileSync(file, 'utf8').trim().split('\n').filter(Boolean).slice(-MAX).map((l) => JSON.parse(l)) : [];
   } catch {
-    rows = [];
+    return [];
   }
+};
+
+/**
+ * The history of the other ots on this computer: each visitor runs its own daemon with its home in
+ * ~/.7ots/ots/<id>/ (SEVENOTS_HOME), so their rows are read from there, tagged with who made them.
+ */
+export function otherInferences() {
+  // a visiting ot lives in <desktop home>/ots/<id>: it sees the host and its fellow visitors too
+  const companion = basename(dirname(HOME)) === 'ots';
+  const root = companion ? dirname(dirname(HOME)) : HOME;
+  const dir = join(root, 'ots');
+  let ids = [];
+  try {
+    ids = readdirSync(dir).filter((d) => /^ots_[a-z0-9]+$/.test(d) && join(dir, d) !== HOME);
+  } catch {}
+  const host = companion ? [{ home: root, id: readJson(join(root, 'config.json'))?.account?.otsId || 'local' }] : [];
+  return [...host, ...ids.map((id) => ({ home: join(dir, id), id }))].flatMap(({ home, id }) => {
+    const name = readJson(join(home, 'identity.json'))?.name || id;
+    return readRows(join(home, 'inferences.jsonl')).map((r) => ({ ...r, ot: { id, name } }));
+  });
+}
+
+export function createInferenceLog() {
+  let rows = readRows(FILE());
   let since = 0;
   const add = (row) => {
     rows.push(row);