@7ots/cli 0.1.5 → 0.1.7

package/cli/lib/pet-server.mjs

@@ -9,8 +9,18 @@
  *   POST /event   X-7ots-Token         { type: tool|shell|prompt|stop|notify|start|feed|play|sleep|wake|say, … }
  *   POST /tts     X-7ots-Token         { text } → audio with the configured voice
  *   POST /ask     X-7ots-Token         { text } → { reply, actions }   reminders, notes, open a site (assistant.mjs)
+ *   POST /stt     X-7ots-Token         raw audio (webm/ogg) → { text }   voice control (stt.mjs)
  *   GET  /reminders?token=…            { reminders, notes }
+ *   GET  /inferences?token=…           the brain's history: what was sent (the data it used) and what came back
+ *   GET  /memory?token=…               everything it keeps about you: notes, what it saw, what it said, its state
+ *   GET  /account                      7ots.com account: signed in?, its ots · POST /account/login|use|logout
+ *   POST /screen/look                  look at the screen now (access.screen) · POST /seen/forget
  *   POST /reminders/cancel             { id }
+ *   GET  /processes                    what the pet is running (reminders, watchers, screen) + the computer's (access.processes)
+ *   POST /watchers/cancel              { id | 'all' }
+ *   GET  /cloud                        7ots.com link + the cloud assistant's VM status (integrations.mjs)
+ *   GET  /orquesta/projects · POST /orquesta/send { projectId, text } · GET /orquesta/prompt?id=   your Orquesta agents
+ *   POST /character/letta              write the character sheet into a Letta agent's persona (LETTA_API_KEY)
  *   GET  /settings?token=…             the settings page: brain, what it may see and do, notes, reminders
  *   GET  /config?token=…               { config: { brain, pet, access }, clis, keys: { NAME: bool }, … }
  *   POST /config                       { brain?, pet?, access?, keys? } → saved to ~/.7ots and applied live
@@ -24,13 +34,27 @@
 
 import { createServer } from 'node:http';
 import { randomBytes, timingSafeEqual } from 'node:crypto';
-import { readFileSync, existsSync, writeFileSync, chmodSync } from 'node:fs';
+import { readFileSync, existsSync, writeFileSync, chmodSync, mkdirSync, symlinkSync } from 'node:fs';
+import { cardShot } from './card-shot.mjs';
 import { join } from 'node:path';
-import { createAssistant } from './assistant.mjs';
+import { createAssistant, notify, tr } from './assistant.mjs';
+import { createWatchers, processes, processSummary } from './watchers.mjs';
+import { createInferenceLog } from './inferences.mjs';
 import { AI_CLIS, createBrain, detectClis, petSystem } from './brain.mjs';
 import { env, loadConfig, saveConfig, saveKey } from './config.mjs';
 import { loadIdentity } from './identity.mjs';
+import { sttProvider, transcribe } from './stt.mjs';
+import { localVoices, synthesizeLocal, warmLocal } from './tts-local.mjs';
+import { createScreenWatcher } from './screen.mjs';
+import { createSiteContext } from './prowl.mjs';
+import { SEVENOTS_URL, logout as accountLogout, me as accountMe, pull as pullOt, signedIn, startLogin, use as useOt } from './account.mjs';
+import { openUrl } from './open.mjs';
+import { VM_KINDS } from './vm.mjs';
+import { cloudStatus, createExtras, lettaSync, normalizeCharacter, normalizeIntegrations } from './integrations.mjs';
+import { spawn } from 'node:child_process';
+import { openSync } from 'node:fs';
 import { line } from './lines.mjs';
+import { defineIdentity } from '../../src/identity/schema.js';
 import { ensureHome, homeFile, PET_PORT, PKG_ROOT } from './paths.mjs';
 import { applyEvent, loadPet, need, savePet, tick, view } from './pet-core.mjs';
 
@@ -72,7 +96,9 @@ export async function postPet(path, body, port = PET_PORT) {
   }
 }
 
-const SETTABLE_KEYS = ['ANTHROPIC_API_KEY', 'OPENAI_API_KEY', 'ORQUESTA_TOKEN'];
+const SETTABLE_KEYS = ['ANTHROPIC_API_KEY', 'OPENAI_API_KEY', 'ORQUESTA_TOKEN', 'ELEVENLABS_API_KEY', 'APUCHAT_VOICE_TOKEN', 'XAI_API_KEY', 'FISH_API_KEY', 'LETTA_API_KEY', 'APUMAIL_TOKEN'];
+// The settings page speaks the human's language: SEVENOTS_LANG, config.lang, the system's, then the ot's.
+const uiLangOf = (c, fallback) => [process.env.SEVENOTS_LANG, c.lang, String(process.env.LC_ALL || process.env.LC_MESSAGES || process.env.LANG || '').slice(0, 2).toLowerCase(), fallback].find((l) => ['en', 'es', 'pt'].includes(l)) || 'en';
 const brainLabel = (b = {}) => (b.kind === 'cli' ? `${b.cli}${b.model ? ` · ${b.model}` : ''}` : b.kind === 'api' ? `${b.provider || 'api'}${b.model ? ` · ${b.model}` : ''}` : b.kind || 'lines');
 
 const GAP = { 0: Infinity, 1: 10 * 60_000, 2: 90_000, 3: 20_000 }; // minimum silence between spontaneous lines
@@ -87,7 +113,10 @@ export function startPetServer({ port = PET_PORT, log = () => {} } = {}) {
   const { identity } = loadIdentity();
   if (!identity) throw Object.assign(new Error('no identity'), { code: 'NO_IDENTITY' });
   const lang = identity.language || 'en';
-  let brain = createBrain(config.brain, config.home); // swapped live from the settings page
+  let brainImpl = createBrain(config.brain, config.home); // swapped live from the settings page
+  const inferences = createInferenceLog();
+  if (config.voice.kind === 'local') warmLocal();
+  const brain = inferences.wrap(() => brainImpl, () => brainLabel(config.brain)); // every call lands in the history
   const pet = tick(loadPet());
   const clients = new Set();
   const history = []; // last lines (so the AI doesn't repeat itself)
@@ -95,6 +124,7 @@ export function startPetServer({ port = PET_PORT, log = () => {} } = {}) {
   let thinking = false;
   let lastSpoke = 0;
   let lastIdle = Date.now();
+  let viewSet = null; // 2D/3D changed in the settings since start: pages that (re)connect pick it up too
 
   const broadcast = (msg) => {
     const data = `data: ${JSON.stringify({ state: view(pet), ...msg })}\n\n`;
@@ -114,6 +144,7 @@ export function startPetServer({ port = PET_PORT, log = () => {} } = {}) {
       broadcast({ thinking: true, gesture });
       try {
         text = await brain.think({
+          purpose: kind,
           system: petSystem(identity, { lang }),
           messages: [{ role: 'user', content: `${situation}${history.length ? `\n(Things you already said: ${history.join(' | ')})` : ''}` }],
           timeoutMs: 30000,
@@ -148,7 +179,7 @@ export function startPetServer({ port = PET_PORT, log = () => {} } = {}) {
     hungry: () => `You are hungry (food ${Math.round(pet.food)}/100). Ask for food; the command is "7ots feed".`,
     bored: () => `You are bored (fun ${Math.round(pet.fun)}/100). Ask to play; the command is "7ots play".`,
     sleepy: () => `You are very tired. Ask for a nap; the command is "7ots sleep".`,
-    idle: () => `Nothing happened for a while. Say something in character about keeping them company, their work or their wellbeing.`,
+    idle: () => `Nothing happened for a while.${watcher?.now() && Date.now() - watcher.now().at < 30 * 60_000 ? ` (On their screen lately: ${watcher.now().doing})` : ''} Say something in character about keeping them company, their work or their wellbeing.`,
   };
 
   /** Event → one feed row: { kind, ok, text, at }. Care actions and `say` are not activity. */
@@ -171,8 +202,13 @@ export function startPetServer({ port = PET_PORT, log = () => {} } = {}) {
   function onEvent(ev) {
     const act = track(ev);
     if (act) broadcast({ activity: act });
+    // Something in the agent's terminal needs you: walk over there and point at it.
+    if (ev.type === 'stop' || ev.type === 'notify' || (ev.type === 'shell' && ![0, 130].includes(Number(ev.code)))) broadcast({ point: 'agent' });
     const r = applyEvent(pet, ev);
     if (r.effect || r.morph) broadcast({ effect: r.effect, morph: r.morph });
+    // asleep: only urgent things (the agent waiting, finished work, a message) stir it, and it dozes off again
+    if (pet.asleep && ev.type !== 'sleep' && !r.stir) return broadcast({});
+    if (r.stir) broadcast({ stir: true });
     if (ev.type === 'say' && ev.text) {
       lastSpoke = Date.now();
       broadcast({ say: String(ev.text).slice(0, 300), gesture: 'wave' });
@@ -202,18 +238,77 @@ export function startPetServer({ port = PET_PORT, log = () => {} } = {}) {
     broadcast({});
   }, 60_000);
 
+  // Watchers: a price or a program it waits for, then it tells you (like a reminder, on a condition).
+  const watchers = createWatchers({
+    log,
+    onFire: (w, now) => {
+      const line = tr(w.lang || lang).watchFire(w, now);
+      lastSpoke = Date.now();
+      pet.lastTalk = lastSpoke;
+      if (config.access.notify !== false) notify(`${identity.name} · 7ots`, line);
+      broadcast({ say: line, gesture: 'wave', effect: 'exclaim', watcher: w, point: 'user', stir: pet.asleep });
+    },
+  });
+
   // The assistant: reminders that speak, notify and open the tab; notes it learns.
   const assistant = createAssistant({
-    brain: { get kind() { return brain.kind; }, think: (o) => brain.think(o) },
+    brain,
     access: () => config.access,
     lang,
     name: identity.name,
     log,
-    system: () => petSystem(identity, { lang, role: 'assistant' }),
+    watchers,
+    procs: () => processSummary(),
+    system: (said) => petSystem(identity, { lang: said || 'auto', role: 'assistant' }),
+    // offload to the ot's cloud worker (access.vm): needs this computer signed in to 7ots.com
+    cloud: () => (env().SEVENOTS_TOKEN && config.account?.otsId) || null,
+    say: (text) => {
+      lastSpoke = Date.now();
+      pet.lastTalk = lastSpoke;
+      broadcast({ say: text, gesture: 'wave', effect: 'exclaim', point: 'user', stir: pet.asleep });
+    },
+    // Prowl.world guides for sites mentioned (or, with access.screen, in the active window's title)
+    sites: createSiteContext({
+      enabled: () => config.access.sites !== false,
+      screen: () => config.access.screen === true,
+      windows: () => watcher?.seen?.windows || [],
+      log,
+    }),
+    // logs, email, Orquesta agents, custom integrations (settings → Permissions)
+    extra: createExtras({
+      config: () => config,
+      brain,
+      log,
+      system: (said) => petSystem(identity, { lang: said || 'auto', role: 'assistant' }),
+      onLater: (text) => {
+        lastSpoke = Date.now();
+        pet.lastTalk = lastSpoke;
+        if (config.access.notify !== false) notify(`${identity.name} · 7ots`, text);
+        broadcast({ say: text, gesture: 'wave', effect: 'exclaim', point: 'user', stir: pet.asleep });
+      },
+    }),
     onFire: (r, text) => {
       lastSpoke = Date.now();
       pet.lastTalk = lastSpoke;
-      broadcast({ say: text, gesture: 'wave', effect: 'exclaim', reminder: r });
+      broadcast({ say: text, gesture: 'wave', effect: 'exclaim', reminder: r, point: r.open && config.access.open ? 'browser' : 'user', stir: pet.asleep });
+    },
+  });
+
+  // What you are doing (access.screen): active window + a screenshot now and then, summed up by the brain.
+  const watcher = createScreenWatcher({
+    brain,
+    enabled: () => config.access.screen === true,
+    every: () => Math.max(1, Number(config.screen?.every) || 5),
+    lang,
+    log,
+    onSeen: (row) => {
+      broadcast({ seen: row });
+      if (!row.say || pet.asleep || Date.now() - lastSpoke < GAP[annoy] || Math.random() >= CHATTY[annoy]) return;
+      lastSpoke = Date.now();
+      pet.lastTalk = lastSpoke;
+      history.push(row.say);
+      if (history.length > 6) history.shift();
+      broadcast({ say: row.say, gesture: 'point' });
     },
   });
 
@@ -240,9 +335,63 @@ export function startPetServer({ port = PET_PORT, log = () => {} } = {}) {
     return a.length === b.length && timingSafeEqual(a, b);
   };
 
-  const page = (file = 'pet.html') =>
+  const page = (file = 'pet.html', extra = {}) =>
     readFileSync(join(PKG_ROOT, 'cli', 'pet', file), 'utf8')
-      .replace('__BOOT__', JSON.stringify({ token, identity, voice: config.voice, lang, annoy, brain: brainLabel(config.brain), activity }).replace(/</g, '\\u003c'));
+      .replace('__BOOT__', JSON.stringify({ token, pid: process.pid, companion: !!process.env.SEVENOTS_COMPANION, identity, otsId: config.account?.otsId || '', voice: config.voice, lang, annoy, brain: brainLabel(config.brain), activity, stt: sttProvider(env()), ...extra }).replace(/</g, '\\u003c'));
+
+  // Visitors: other ots of the account invited onto this desktop (their look, saved so they come offline too).
+  // The desktop shell opens a window for each and stages scenes between them (see electron/director.cjs).
+  const VISITORS = homeFile('visitors.json');
+  const visitors = () => {
+    try {
+      return JSON.parse(readFileSync(VISITORS, 'utf8')).filter((v) => v?.id && v.identity?.name);
+    } catch {
+      return [];
+    }
+  };
+
+  // A second ot with everything: its own daemon (brain, voice, memory, reminders, settings) in ~/.7ots/ots/<id>,
+  // on the next port. It starts with this one's settings and keys (keys.json is shared), and lives as long as it.
+  // At most one for now. The old look-only visitors (no `full`) still work.
+  const MAX_FULL = 1;
+  const companion = (v) => {
+    const dir = homeFile(join('ots', v.id));
+    return { dir, url: `http://127.0.0.1:${port + 1}`, tokenFile: join(dir, 'pet.token') };
+  };
+  async function startCompanion(v) {
+    const c = companion(v);
+    const up = await fetch(`${c.url}/health`).then((r) => (r.ok ? r.json() : null), () => null);
+    if (up && up.name === v.identity.name) return;
+    mkdirSync(c.dir, { recursive: true });
+    const f = (n) => join(c.dir, n);
+    if (!existsSync(f('identity.json'))) writeFileSync(f('identity.json'), JSON.stringify(v.identity, null, 2));
+    if (!existsSync(f('config.json'))) {
+      const next = { ...JSON.parse(JSON.stringify(config)), account: { otsId: v.id, name: v.identity.name, at: Date.now() } };
+      if (['local', '7ots'].includes(next.home?.kind || 'local')) next.home = { kind: '7ots', url: `${SEVENOTS_URL}/api/o/${v.id}` };
+      writeFileSync(f('config.json'), JSON.stringify(next, null, 2));
+    }
+    try {
+      if (!existsSync(f('keys.json')) && existsSync(homeFile('keys.json'))) symlinkSync(homeFile('keys.json'), f('keys.json'));
+    } catch {}
+    const out = openSync(homeFile('pet.log'), 'a');
+    spawn(process.execPath, [join(PKG_ROOT, 'cli', '7ots.mjs'), 'pet', '--daemon'], {
+      cwd: c.dir, // never pick up a project's .7ots/identity.json
+      detached: true,
+      stdio: ['ignore', out, out],
+      env: { ...process.env, SEVENOTS_COMPANION: '1', SEVENOTS_HOME: c.dir, SEVENOTS_PET_PORT: String(port + 1), SEVENOTS_PORT_WAIT: '1' },
+    }).unref();
+    log(`companion: ${v.identity.name} on ${c.url}`);
+  }
+  const quitCompanion = (v) => {
+    const c = companion(v);
+    let t = '';
+    try {
+      t = readFileSync(c.tokenFile, 'utf8').trim();
+    } catch {}
+    return fetch(`${c.url}/quit`, { method: 'POST', headers: { 'X-7ots-Token': t, 'Content-Type': 'application/json' }, body: '{}' }).catch(() => {});
+  };
+  const fullOnes = () => visitors().filter((v) => v.full);
+  if (!process.env.SEVENOTS_COMPANION) fullOnes().forEach((v) => startCompanion(v).catch((e) => log(`companion: ${e.message}`)));
 
   const server = createServer(async (req, res) => {
     const url = new URL(req.url, 'http://127.0.0.1');
@@ -257,26 +406,100 @@ export function startPetServer({ port = PET_PORT, log = () => {} } = {}) {
       if (!existsSync(f)) return res.writeHead(404).end('run npm run build');
       return res.writeHead(200, { 'Content-Type': 'text/javascript; charset=utf-8', 'Cache-Control': 'no-cache' }).end(readFileSync(f));
     }
+    if (req.method === 'GET' && p === '/favicon.svg') return res.writeHead(200, { 'Content-Type': 'image/svg+xml', 'Cache-Control': 'max-age=86400' }).end(readFileSync(join(PKG_ROOT, 'brand', 'favicon.svg')));
     const authed = okToken(url.searchParams.get('token') || req.headers['x-7ots-token']);
     if (!authed) return json(401, { error: 'token' });
 
     if (req.method === 'GET' && p === '/pet') {
-      return res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8', 'Cache-Control': 'no-store', 'Referrer-Policy': 'no-referrer' }).end(page());
+      const g = url.searchParams.get('guest');
+      const v = g && visitors().find((x) => x.id === g);
+      if (g && !v) return res.writeHead(404).end();
+      return res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8', 'Cache-Control': 'no-store', 'Referrer-Policy': 'no-referrer' }).end(v ? page('pet.html', { identity: v.identity, guest: v.id, voice: { kind: 'none' } }) : page());
     }
+    if (req.method === 'GET' && p === '/visitors')
+      return json(200, visitors().map((v) => {
+        if (!v.full) return { id: v.id, name: v.identity.name };
+        const c = companion(v);
+        let t = '';
+        try {
+          t = readFileSync(c.tokenFile, 'utf8').trim();
+        } catch {}
+        return { id: v.id, name: v.identity.name, url: c.url, token: t }; // no token yet: its daemon is still starting
+      }));
     if (req.method === 'GET' && p === '/settings') {
-      return res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8', 'Cache-Control': 'no-store', 'Referrer-Policy': 'no-referrer', 'X-Frame-Options': 'DENY' }).end(page('settings.html'));
+      return res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8', 'Cache-Control': 'no-store', 'Referrer-Policy': 'no-referrer', 'X-Frame-Options': 'DENY' }).end(page('settings.html', { uiLang: uiLangOf(config, lang) }));
+    }
+    if (req.method === 'GET' && p === '/card') {
+      return res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8', 'Cache-Control': 'no-store', 'Referrer-Policy': 'no-referrer' }).end(page('card.html'));
+    }
+    // The card as a high-res PNG (card-shot.mjs: headless Chrome, so blend modes and 3D come out as on screen).
+    if (req.method === 'GET' && p === '/card.png') {
+      const q = new URLSearchParams({ shot: '1', token });
+      for (const k of ['id', 'foil', '3d']) if (url.searchParams.get(k)) q.set(k, url.searchParams.get(k));
+      try {
+        const png = await cardShot(`http://127.0.0.1:${port}/card?${q}`, { scale: Math.min(8, Math.max(1, Number(url.searchParams.get('scale')) || 4)), gl: !!url.searchParams.get('3d'), timeout: url.searchParams.get('3d') ? 150000 : 45000 });
+        return res.writeHead(200, { 'Content-Type': 'image/png', 'Cache-Control': 'no-store' }).end(png);
+      } catch (e) {
+        return json(e.status || 500, { error: e.message });
+      }
     }
     if (req.method === 'GET' && p === '/config') return json(200, settingsView());
     if (req.method === 'GET' && p === '/state') return json(200, { identity, state: view(pet), config: { voice: config.voice, pet: config.pet, brain: config.brain.kind } });
     if (req.method === 'GET' && p === '/events') {
       res.writeHead(200, { 'Content-Type': 'text/event-stream', 'Cache-Control': 'no-cache', Connection: 'keep-alive' });
-      res.write(`data: ${JSON.stringify({ state: view(pet) })}\n\n`);
+      res.write(`data: ${JSON.stringify({ state: view(pet), ...(viewSet ? { view: viewSet } : {}) })}\n\n`);
       clients.add(res);
       req.on('close', () => clients.delete(res));
       return;
     }
+    if (req.method === 'GET' && p === '/inferences') return json(200, { inferences: inferences.list(Number(url.searchParams.get('n')) || 100) });
+    if (req.method === 'GET' && p === '/memory') return json(200, { notes: assistant.notes, reminders: assistant.reminders, seen: watcher.seen, said: history, activity, pet: view(pet) });
+    if (req.method === 'GET' && p === '/account') {
+      const base = { url: SEVENOTS_URL, current: config.account || null, signedIn: signedIn() };
+      if (!base.signedIn) return json(200, base);
+      try {
+        return json(200, { ...base, ...(await accountMe()) });
+      } catch (e) {
+        return json(200, { ...base, signedIn: signedIn(), error: e.message });
+      }
+    }
+    if (req.method === 'GET' && p === '/processes')
+      return json(200, {
+        reminders: assistant.reminders,
+        watchers: watchers.list,
+        screen: { on: config.access.screen === true, every: config.screen.every, last: watcher.seen?.[0] || null },
+        system: config.access.processes ? await processes({ n: 60 }) : null,
+      });
     if (req.method === 'GET' && p === '/reminders') return json(200, { reminders: assistant.reminders, notes: assistant.notes });
+    if (req.method === 'GET' && p === '/cloud') return json(200, await cloudStatus(config));
+    if (req.method === 'GET' && (p === '/orquesta/projects' || p === '/orquesta/prompt')) {
+      if (!env().ORQUESTA_TOKEN) return json(200, { connected: false });
+      try {
+        const o = await import('./orquesta.mjs');
+        if (p === '/orquesta/projects') return json(200, { connected: true, projects: await o.agentProjects() });
+        return json(200, { connected: true, ...(await o.agentTask(String(url.searchParams.get('id') || '').slice(0, 80))) });
+      } catch (e) {
+        return json(e.status === 401 ? 200 : 502, { connected: e.status !== 401, error: e.message });
+      }
+    }
     if (req.method !== 'POST') return json(405, { error: 'method' });
+    if (p === '/stt') {
+      const chunks = [];
+      let n = 0;
+      for await (const c of req) {
+        if ((n += c.length) > 8 * 1024 * 1024) return json(413, { error: 'too large' });
+        chunks.push(c);
+      }
+      try {
+        const t0 = Date.now();
+        const { text, provider } = await transcribe({ audio: Buffer.concat(chunks), contentType: req.headers['content-type'], lang: '', env: env() }); // '' = detect the language spoken
+        log(`stt: ${provider} ${Date.now() - t0}ms ${n}B → ${text.length} chars`);
+        return json(200, { text });
+      } catch (e) {
+        log(`stt: ${e.message}`);
+        return json(e.status || 502, { error: e.message });
+      }
+    }
     let body = '';
     for await (const c of req) if ((body += c).length > 64 * 1024) return json(413, { error: 'too large' });
     let data = {};
@@ -294,9 +517,16 @@ export function startPetServer({ port = PET_PORT, log = () => {} } = {}) {
       const kind = config.voice.kind;
       if (['none', 'browser'].includes(kind)) return json(501, { error: 'browser voice' });
       try {
+        if (kind === 'local') {
+          const { audio, contentType } = await synthesizeLocal(String(data.text || '').slice(0, 600), { lang });
+          return res.writeHead(200, { 'Content-Type': contentType }).end(audio);
+        }
         const { synthesize } = await import('../../server/tts.mjs');
-        const voice = { ...identity.voice, provider: kind, ...(config.voice.voiceId ? { voiceId: config.voice.voiceId } : {}) };
-        const { audio, contentType } = await synthesize({ text: String(data.text || '').slice(0, 600), voice, env: env() });
+        // the identity's voice id/model belong to its own provider: not sent to another (an ElevenLabs id means nothing to Fish)
+        const iv = identity.voice || {};
+        const voice = { ...iv, ...(iv.provider === kind ? {} : { voiceId: '', model: '' }), provider: kind, ...(config.voice.voiceId ? { voiceId: config.voice.voiceId } : {}) };
+        // process.env too: XAI_TTS_VOICE, FISH_VOICE_ID, APUCHAT_VOICE_URL… (the keys still come from env())
+        const { audio, contentType } = await synthesize({ text: String(data.text || '').slice(0, 600), voice, env: { ...process.env, ...env() } });
         return res.writeHead(200, { 'Content-Type': contentType }).end(audio);
       } catch (e) {
         return json(e.status || 502, { error: e.message });
@@ -308,7 +538,7 @@ export function startPetServer({ port = PET_PORT, log = () => {} } = {}) {
       broadcast({ thinking: true, activity: track({ type: 'prompt', text }) });
       const r = await assistant.ask(text);
       lastSpoke = Date.now();
-      broadcast({ thinking: false, say: r.reply, gesture: r.actions.length ? 'nod' : null });
+      broadcast({ thinking: false, stir: pet.asleep, say: r.reply, gesture: r.actions.length ? 'nod' : null, point: r.actions.some((a) => a.type === 'open') ? 'browser' : null });
       return json(200, r);
     }
     if (p === '/config') {
@@ -319,7 +549,7 @@ export function startPetServer({ port = PET_PORT, log = () => {} } = {}) {
       if (brain.kind === 'lines') return json(200, { ok: true, text: line('hello', lang, { name: identity.name, level: pet.level }), ms: 0 });
       const t0 = Date.now();
       try {
-        const text = await brain.think({ system: petSystem(identity, { lang }), messages: [{ role: 'user', content: 'Your human is checking that your brain works. Say hi in one short line.' }], timeoutMs: 45000 });
+        const text = await brain.think({ purpose: 'test', system: petSystem(identity, { lang }), messages: [{ role: 'user', content: 'Your human is checking that your brain works. Say hi in one short line.' }], timeoutMs: 45000 });
         if (!text) throw new Error('empty answer');
         broadcast({ say: text, gesture: 'wave' });
         return json(200, { ok: true, text, ms: Date.now() - t0 });
@@ -327,10 +557,83 @@ export function startPetServer({ port = PET_PORT, log = () => {} } = {}) {
         return json(200, { ok: false, error: e.message, ms: Date.now() - t0 });
       }
     }
+    if (p === '/screen/look') return json(200, { seen: config.access.screen ? await watcher.look({ force: true }) : null, enabled: config.access.screen });
+    if (p === '/seen/forget') return watcher.forget(), json(200, { ok: true });
+    if (p === '/account/login') {
+      try {
+        const { url, done } = await startLogin({ open: openUrl });
+        done.then(() => broadcast({ account: true }), (e) => log(`account: ${e.message}`));
+        return json(200, { url });
+      } catch (e) {
+        return json(502, { error: e.message });
+      }
+    }
+    if (p === '/account/logout') return await accountLogout(), json(200, { ok: true });
+    if (p === '/account/visitor') {
+      const vid = String(data.id || '');
+      if (!/^[a-z0-9_]{4,40}$/.test(vid)) return json(400, { error: 'id' });
+      if (process.env.SEVENOTS_COMPANION) return json(400, { error: 'the second ot cannot invite more' });
+      let list = visitors().filter((v) => v.id !== vid);
+      if (data.on) {
+        if (vid === config.account?.otsId) return json(400, { error: 'that one already lives here' });
+        if (list.length >= MAX_FULL) return json(400, { error: `max ${MAX_FULL + 1} ots on this computer` });
+        try {
+          const { identity: vi } = await pullOt(vid);
+          list.push({ id: vid, identity: defineIdentity(vi), full: true, at: Date.now() });
+        } catch (e) {
+          return json(e.status || 502, { error: e.message });
+        }
+      } else {
+        const gone = visitors().find((v) => v.id === vid);
+        if (gone?.full) quitCompanion(gone);
+      }
+      writeFileSync(VISITORS, JSON.stringify(list, null, 2));
+      list.filter((v) => v.full).forEach((v) => startCompanion(v).catch((e) => log(`companion: ${e.message}`)));
+      log(`visitors: ${list.map((v) => v.identity.name).join(', ') || 'none'}`);
+      return json(200, { ok: true, visitors: list.map((v) => v.id) });
+    }
+    if (p === '/account/use') {
+      if (!/^[a-z0-9_]{4,40}$/.test(String(data.id || ''))) return json(400, { error: 'id' });
+      try {
+        const r = await useOt(data.id);
+        log(`account: now ${r.identity.name} (${data.id})`);
+        json(200, { ok: true, name: r.identity.name });
+      } catch (e) {
+        return json(e.status || 502, { error: e.message });
+      }
+      return restart(); // identity, language and name are read once at start
+    }
+    if (p === '/inferences/clear') return inferences.clear(), json(200, { ok: true });
     if (p === '/notes/forget') return json(200, { ok: assistant.forget(data.at === 'all' ? 'all' : String(data.at ?? '')) });
+    if (p === '/watchers/cancel') return json(200, { ok: watchers.cancel(String(data.id || '')) });
     if (p === '/reminders/cancel') return json(200, { ok: assistant.cancel(String(data.id || '')) });
+    if (p === '/orquesta/send') {
+      const projectId = String(data.projectId || '');
+      const text = String(data.text || '').trim();
+      if (!/^[\w-]{1,80}$/.test(projectId) || !text) return json(400, { error: 'projectId, text' });
+      try {
+        return json(200, await (await import('./orquesta.mjs')).sendToAgent(projectId, text));
+      } catch (e) {
+        return json(e.status === 400 ? 400 : 502, { error: e.message });
+      }
+    }
+    if (p === '/character/letta') {
+      try {
+        const r = await lettaSync(identity, config.character);
+        if (r.created) {
+          const next = loadConfig();
+          next.character = { ...next.character, letta: { on: true, agentId: r.agentId } };
+          saveConfig(next);
+          config = loadConfig();
+        }
+        return json(200, r);
+      } catch (e) {
+        return json(e.status === 400 ? 400 : 502, { error: e.message });
+      }
+    }
     if (p === '/quit') {
       json(200, { ok: true });
+      await Promise.all(fullOnes().map(quitCompanion)); // the second ot leaves with it (a restart keeps it)
       return stop();
     }
     return json(404, { error: 'not found' });
@@ -342,9 +645,19 @@ export function startPetServer({ port = PET_PORT, log = () => {} } = {}) {
     return {
       name: identity.name,
       lang,
-      config: { brain: config.brain, pet: config.pet, access: config.access },
+      config: { brain: config.brain, pet: config.pet, access: config.access, voice: config.voice, screen: config.screen },
       brain: brainLabel(config.brain),
       clis: detectClis(),
+      stt: sttProvider(keys),
+      voice: config.voice,
+      voices: { local: localVoices(), keys: { elevenlabs: Boolean(keys.ELEVENLABS_API_KEY), openai: Boolean(keys.OPENAI_API_KEY), apuchat: Boolean(keys.APUCHAT_VOICE_TOKEN), grok: Boolean(keys.XAI_API_KEY), fish: Boolean(keys.FISH_API_KEY) } },
+      uiLang: uiLangOf(config, lang),
+      configLang: config.lang || '',
+      integrations: config.integrations,
+      character: config.character,
+      account: config.account || null,
+      screen: config.screen,
+      vision: Boolean(brain.vision),
       allClis: Object.keys(AI_CLIS),
       keys: Object.fromEntries(SETTABLE_KEYS.map((k) => [k, Boolean(keys[k])])),
       home: { kind: config.home.kind, url: Boolean(config.home.url) },
@@ -376,11 +689,30 @@ export function startPetServer({ port = PET_PORT, log = () => {} } = {}) {
         next.brain = { kind: '7ots' };
       } else return 'kind';
     }
+    const viewWas = next.pet.view || '2d';
     if (d.pet) {
       if (d.pet.annoy !== undefined) next.pet.annoy = Math.max(0, Math.min(3, Math.round(Number(d.pet.annoy)) || 0));
       if (['2d', '3d'].includes(d.pet.view)) next.pet.view = d.pet.view;
     }
     if (d.access) for (const k of Object.keys(next.access)) if (typeof d.access[k] === 'boolean') next.access[k] = d.access[k];
+    if (Array.isArray(d.access?.vmKinds)) next.access.vmKinds = [...new Set(d.access.vmKinds.filter((k) => VM_KINDS.includes(k)))];
+    if (d.lang !== undefined) {
+      if (!['', 'en', 'es', 'pt'].includes(d.lang)) return 'lang';
+      next.lang = d.lang;
+    }
+    try {
+      if (d.integrations) next.integrations = normalizeIntegrations(d.integrations, next.integrations);
+      if (d.character) next.character = normalizeCharacter(d.character, next.character);
+    } catch (e) {
+      return e.message;
+    }
+    if (d.screen?.every !== undefined) next.screen.every = Math.max(1, Math.min(60, Math.round(Number(d.screen.every)) || 5));
+    let reload = false;
+    if (d.voice) {
+      if (!['none', 'browser', 'local', 'elevenlabs', 'openai', 'apuchat', 'grok', 'fish'].includes(d.voice.kind)) return 'voice';
+      reload = d.voice.kind !== next.voice.kind;
+      next.voice = { ...next.voice, kind: d.voice.kind };
+    }
     if (d.keys) {
       for (const [k, v] of Object.entries(d.keys)) {
         if (!SETTABLE_KEYS.includes(k) || typeof v !== 'string' || v.length > 400) return 'key';
@@ -390,23 +722,42 @@ export function startPetServer({ port = PET_PORT, log = () => {} } = {}) {
     saveConfig(next);
     config = loadConfig();
     annoy = annoyOf(config);
-    brain = createBrain(config.brain, config.home);
+    brainImpl = createBrain(config.brain, config.home);
+    if (config.voice.kind === 'local') warmLocal();
+    if (reload) setTimeout(() => broadcast({ reload: true }), 100); // the page reads its voice at load
+    // 2D ↔ 3D: open pet windows switch now (the page, or the desktop shell when it needs the GPU back on).
+    else if ((config.pet.view || '2d') !== viewWas) (viewSet = config.pet.view), setTimeout(() => broadcast({ view: viewSet }), 100);
     log(`settings: brain ${brainLabel(config.brain)}`);
     return null;
   }
 
-  function stop() {
+  /** A fresh daemon with the new identity; open pages wait for it and reload. */
+  function restart() {
+    broadcast({ restart: true });
+    // Spawned by this process right before it exits (a timer after stop() never fired: exit came first).
+    // The new one retries the port while this one lets go of it.
+    stop(() => {
+      const out = openSync(homeFile('pet.log'), 'a');
+      spawn(process.execPath, [join(PKG_ROOT, 'cli', '7ots.mjs'), 'pet', '--daemon'], { detached: true, stdio: ['ignore', out, out], env: { ...process.env, SEVENOTS_PORT_WAIT: '1' } }).unref();
+    });
+  }
+
+  function stop(then) {
     clearInterval(timer);
     assistant.stop();
+    watchers.stop();
     stopWatch();
     savePet(pet);
     for (const c of clients) c.end();
     server.close();
-    setTimeout(() => process.exit(0), 200).unref();
+    server.closeAllConnections?.();
+    setTimeout(() => (then?.(), process.exit(0)), 200).unref();
   }
 
   return new Promise((resolve, reject) => {
-    server.once('error', reject);
+    // After a restart the old daemon may hold the port a moment longer: keep trying for ~10 s.
+    let tries = process.env.SEVENOTS_PORT_WAIT ? 40 : 0;
+    server.on('error', (e) => (e.code === 'EADDRINUSE' && tries-- > 0 ? setTimeout(() => server.listen(port, '127.0.0.1'), 250) : reject(e)));
     server.listen(port, '127.0.0.1', () => {
       log(`pet ${identity.name} on http://127.0.0.1:${port}`);
       setTimeout(() => onEvent({ type: 'start' }), 1500);