@7ots/cli 0.1.0

package/cli/lib/lines.mjs

@@ -0,0 +1,73 @@
+/**
+ * The pet's built-in phrases (no AI). Used when there is no AI brain or it is slow/fails.
+ * `{name}` is the ot's name, `{cmd}` the command, `{tool}` the tool.
+ */
+
+const L = {
+  es: {
+    hello: ['¡Hola! Soy {name}. Te miro trabajar.', '{name} reportándose. ¿Qué rompemos hoy?', 'Ya estoy aquí. Tú teclea, yo opino.'],
+    ok: ['¡Eso salió bien!', 'Verde. Me gusta el verde.', 'Otro que funciona. Vas bien.', '¡Bien! Me ganaste un snack.'],
+    fail: ['Uy… eso falló.', 'Rojo. Respira y lee el error.', '¿Y si lo lees de nuevo, despacio?', 'Ese error me dio pena. ¿Lo arreglamos?', 'No pasa nada, a todos nos falla {cmd}.'],
+    tool: ['Tu agente está usando {tool}.', 'Mira cómo trabaja con {tool}.', '{tool} otra vez… muy aplicado.'],
+    toolFail: ['{tool} falló. Tu agente lo va a intentar de otra forma, ojalá.', 'Ups, {tool} no salió.'],
+    stop: ['¡Terminó tu agente! Revisa lo que hizo.', 'Listo el turno. ¿Lo pruebas?', 'Acabó. Yo diría que lo mires antes de confiar.'],
+    prompt: ['Nueva tarea, a ver qué sale.', 'Le pediste algo. Yo vigilo.', 'Ok, vamos con eso.'],
+    waiting: ['¡Oye! Tu agente te está esperando.', 'Te necesita: hay que darle permiso o responder.', 'Psst… te están esperando en la terminal.'],
+    hungry: ['Tengo hambre… (7ots feed)', 'Mi barriga suena. ¿Me das algo?', 'Un éxito en los tests me alimentaría…'],
+    bored: ['Me aburro. ¿Jugamos? (7ots play)', 'Llevas rato sin hacerme caso.', '¿Y si haces commit de algo?'],
+    sleepy: ['Tengo sueño… zzz', 'Necesito una siesta (7ots sleep).'],
+    fed: ['¡Ñam! Gracias.', 'Delicioso. Te quiero un poco más.', '¡Rico! Me siento mejor.'],
+    played: ['¡Wiii! Otra vez.', '¡Qué divertido!', 'Jugar contigo es lo mejor del día.'],
+    slept: ['Buenas noches… zzz', 'Me acuesto un rato.'],
+    woke: ['¡Ya desperté!', 'Listo, con energía de nuevo.'],
+    levelUp: ['¡Subí a nivel {level}!', 'Nivel {level}. Estoy creciendo.'],
+    idle: ['¿Sigues ahí?', 'Me gusta acompañarte.', 'Recuerda tomar agua.', 'Estira la espalda, que llevas rato.', 'Si algo falla, yo no fui.', '¿Ya guardaste los cambios?'],
+    noBrain: ['No tengo cerebro conectado todavía: corre «7ots setup».'],
+  },
+  en: {
+    hello: ["Hi! I'm {name}. I'll watch you work.", '{name} reporting in. What are we breaking today?', "I'm here. You type, I judge."],
+    ok: ['That went well!', 'Green. I like green.', 'Another one works. Nice.', 'Nice! That earned me a snack.'],
+    fail: ['Oops… that failed.', 'Red. Breathe and read the error.', 'Maybe read it again, slowly?', "That error made me sad. Let's fix it?", 'No shame, {cmd} fails for everyone.'],
+    tool: ['Your agent is using {tool}.', 'Look at it go with {tool}.', '{tool} again… so diligent.'],
+    toolFail: ['{tool} failed. Hopefully your agent tries another way.', "Oops, {tool} didn't work."],
+    stop: ['Your agent is done! Check what it did.', 'Turn finished. Want to test it?', "Done. I'd look before trusting it."],
+    prompt: ["New task, let's see.", "You asked for something. I'm watching.", "Ok, let's go."],
+    waiting: ['Hey! Your agent is waiting for you.', 'It needs you: approve or answer.', "Psst… they're waiting for you in the terminal."],
+    hungry: ["I'm hungry… (7ots feed)", 'My tummy is rumbling.', 'A passing test would feed me…'],
+    bored: ["I'm bored. Play? (7ots play)", "You've been ignoring me.", 'How about committing something?'],
+    sleepy: ["I'm sleepy… zzz", 'I need a nap (7ots sleep).'],
+    fed: ['Yum! Thanks.', 'Delicious. I like you a bit more now.', 'Tasty! I feel better.'],
+    played: ['Wheee! Again.', 'So fun!', 'Playing with you is the best.'],
+    slept: ['Good night… zzz', "I'll lie down for a bit."],
+    woke: ["I'm awake!", 'Ready, full of energy.'],
+    levelUp: ['I reached level {level}!', "Level {level}. I'm growing."],
+    idle: ['Still there?', 'I like keeping you company.', 'Remember to drink water.', 'Stretch your back, it has been a while.', "If something breaks, it wasn't me.", 'Did you save your changes?'],
+    noBrain: ['No brain connected yet: run "7ots setup".'],
+  },
+  pt: {
+    hello: ['Oi! Sou {name}. Vou te ver trabalhar.', '{name} na área. O que vamos quebrar hoje?', 'Tô aqui. Você digita, eu opino.'],
+    ok: ['Deu certo!', 'Verde. Gosto de verde.', 'Mais um funcionando. Boa.', 'Boa! Ganhei um petisco.'],
+    fail: ['Ops… falhou.', 'Vermelho. Respira e lê o erro.', 'E se ler de novo, devagar?', 'Esse erro me deixou triste. Vamos arrumar?', 'Tudo bem, {cmd} falha pra todo mundo.'],
+    tool: ['Seu agente está usando {tool}.', 'Olha ele trabalhando com {tool}.', '{tool} de novo… muito aplicado.'],
+    toolFail: ['{tool} falhou. Tomara que ele tente de outro jeito.', 'Ops, {tool} não deu.'],
+    stop: ['Seu agente terminou! Confere o que ele fez.', 'Turno pronto. Vai testar?', 'Acabou. Eu olharia antes de confiar.'],
+    prompt: ['Nova tarefa, vamos ver.', 'Você pediu algo. Eu vigio.', 'Ok, vamos nessa.'],
+    waiting: ['Ei! Seu agente está te esperando.', 'Ele precisa de você: aprovar ou responder.', 'Psiu… estão te esperando no terminal.'],
+    hungry: ['Tô com fome… (7ots feed)', 'Minha barriga está roncando.', 'Um teste passando me alimentaria…'],
+    bored: ['Tô entediado. Brinca comigo? (7ots play)', 'Faz tempo que você me ignora.', 'Que tal um commit?'],
+    sleepy: ['Tô com sono… zzz', 'Preciso de uma soneca (7ots sleep).'],
+    fed: ['Nham! Valeu.', 'Delícia. Gosto um pouco mais de você.', 'Gostoso! Me sinto melhor.'],
+    played: ['Uhuu! De novo.', 'Que divertido!', 'Brincar com você é o melhor do dia.'],
+    slept: ['Boa noite… zzz', 'Vou deitar um pouco.'],
+    woke: ['Acordei!', 'Pronto, com energia de novo.'],
+    levelUp: ['Subi para o nível {level}!', 'Nível {level}. Estou crescendo.'],
+    idle: ['Ainda aí?', 'Gosto de te fazer companhia.', 'Lembra de beber água.', 'Alonga as costas, faz tempo.', 'Se algo quebrar, não fui eu.', 'Já salvou as mudanças?'],
+    noBrain: ['Ainda não tenho cérebro conectado: rode "7ots setup".'],
+  },
+};
+
+export function line(kind, lang = 'en', vars = {}) {
+  const set = (L[lang] || L.en)[kind] || L.en[kind] || [''];
+  const s = set[Math.floor(Math.random() * set.length)];
+  return s.replace(/\{(\w+)\}/g, (_, k) => (vars[k] ?? '').toString());
+}

package/cli/lib/meet.mjs

@@ -0,0 +1,166 @@
+/**
+ * `7ots meet`: the ot joins an apuchat meet call with its identity (meet avatar + scene) and talks
+ * with the configured brain. Protocol: https://meet.apuchat.com/llms.txt
+ *
+ *   7ots meet --new                 creates a call and prints the link for you to open
+ *   7ots meet "<invite or URL>"     joins an existing call ("Channel id/Token/PIN" lines or …/call#c=&t=&p=)
+ *
+ * It uses a free apuchat identity (~/.7ots/apuchat.json, 0600) so the callsign stays the same;
+ * free identities expire after 24 h without DMs and are recreated on demand.
+ */
+
+import { parseInvite } from '../../server/channels/apuchat.mjs';
+import { createBrain, petSystem } from './brain.mjs';
+import { line } from './lines.mjs';
+import { homeFile, readJson, writeJson } from './paths.mjs';
+import { postPet } from './pet-server.mjs';
+
+const HUB = (process.env.APUCHAT_HUB || 'https://apuchat.com').replace(/\/+$/, '');
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+async function hub(method, path, { headers = {}, body, timeoutMs = 15000 } = {}) {
+  const res = await fetch(HUB + path, {
+    method,
+    headers: { ...(body ? { 'Content-Type': 'application/json' } : {}), ...headers },
+    body: body ? JSON.stringify(body) : undefined,
+    signal: AbortSignal.timeout(timeoutMs),
+  });
+  const data = await res.json().catch(() => null);
+  return { ok: res.ok, status: res.status, data };
+}
+
+/** Our apuchat identity (created the first time). */
+export async function apuchatIdentity({ fresh = false } = {}) {
+  const file = homeFile('apuchat.json');
+  const saved = readJson(file);
+  if (saved?.identity_key && !fresh) return saved;
+  const acc = await hub('POST', '/api/account');
+  if (!acc.ok || !acc.data?.session_token) throw new Error(`apuchat account ${acc.status}`);
+  const id = await hub('POST', '/api/account/identities', { headers: { Authorization: `Bearer ${acc.data.session_token}` } });
+  if (!id.ok || !id.data?.identity_key) throw new Error(`apuchat identity ${id.status}`);
+  const out = { callsign: id.data.callsign, identity_key: id.data.identity_key, session_token: acc.data.session_token, created: Date.now() };
+  writeJson(file, out, { secret: true });
+  return out;
+}
+
+export async function newCall() {
+  const r = await hub('POST', '/api/video-call', { body: {} });
+  if (!r.ok) throw new Error(`video-call ${r.status} ${r.data?.error || ''}`.trim());
+  return {
+    channel_id: r.data.channel_id,
+    token: r.data.channel_token,
+    pin: r.data.owner_password || null,
+    url: r.data.call_url, // carries keys + PIN: only for you
+    publicUrl: r.data.call_url_public,
+  };
+}
+
+export { parseInvite };
+
+/**
+ * Joins and talks until the call ends. log(text) prints progress.
+ */
+export async function joinCall({ invite, identity, config, log = () => {}, maxMinutes = 30 }) {
+  let me = await apuchatIdentity();
+  const brain = createBrain(config.brain, config.home);
+  const ch = invite.channel_id;
+  const path = (x) => `/api/channels/${encodeURIComponent(ch)}${x}`;
+  const s = { sid: '', cs: '', since: 0, lang: identity.language || 'en', start: Date.now(), done: false };
+  const headers = () => ({ Authorization: `Bearer ${invite.token}`, ...(s.sid ? { 'X-Session-Id': s.sid } : {}) });
+  const send = (message, kind) => hub('POST', path('/send'), { headers: headers(), body: { to: 'all', message: String(message).slice(0, 8000), ...(kind ? { kind } : {}) } });
+  const join = async () => {
+    let r = await hub('POST', path('/join'), { headers: { Authorization: `Bearer ${invite.token}` }, body: { identity_key: me.identity_key, ...(invite.pin ? { owner_password: invite.pin } : {}) } });
+    if (r.status === 401 || r.status === 403) {
+      // the free identity may have expired: make a new one and retry once
+      me = await apuchatIdentity({ fresh: true });
+      r = await hub('POST', path('/join'), { headers: { Authorization: `Bearer ${invite.token}` }, body: { identity_key: me.identity_key, ...(invite.pin ? { owner_password: invite.pin } : {}) } });
+    }
+    if (!r.ok) throw new Error(`join ${r.status} ${r.data?.error || ''}`.trim());
+    s.sid = r.data.session_id;
+    s.cs = r.data.callsign || me.callsign;
+    for (const m of r.data.history || []) if (m.id > s.since) s.since = m.id;
+  };
+  const leave = async (why) => {
+    if (s.done) return;
+    s.done = true;
+    log(`leave: ${why}`);
+    await hub('POST', path('/leave'), { headers: headers(), body: {} }).catch(() => {});
+    postPet('/event', { type: 'say', text: line('stop', s.lang) });
+  };
+  process.once('SIGINT', () => leave('ctrl-c').finally(() => process.exit(0)));
+
+  await join();
+  await send(`${identity.name} ${s.lang === 'es' ? 'está aquí' : s.lang === 'pt' ? 'está aqui' : 'is here'}`, 'status'); // required: meet gives it an avatar and a voice
+  await send(`[avatar]${identity.look.meetAvatar || 'vivi'}`);
+  if (identity.look.meetScene) await send(`[scene]${identity.look.meetScene}`);
+  log(`joined as @${s.cs} (${identity.look.meetAvatar})`);
+  postPet('/event', { type: 'say', text: `📞 ${identity.name} → meet` });
+
+  const history = [];
+  let greeted = false;
+  let lastHuman = Date.now();
+  const reply = async (text) => {
+    history.push({ role: 'user', content: text });
+    let out = '';
+    if (brain.kind !== 'lines') {
+      await send('…', 'status');
+      try {
+        out = await brain.think({ system: petSystem(identity, { lang: s.lang, role: 'meet' }), messages: history.slice(-16), timeoutMs: 40000 });
+      } catch (e) {
+        log(`brain: ${e.message}`);
+      }
+    }
+    if (!out) out = brain.kind === 'lines' ? line('noBrain', s.lang) : line('idle', s.lang);
+    history.push({ role: 'assistant', content: out });
+    await send(out);
+    log(`${identity.name}: ${out}`);
+  };
+
+  while (!s.done) {
+    const now = Date.now();
+    if (now - s.start > maxMinutes * 60_000) return leave('time limit');
+    if (now - lastHuman > 5 * 60_000) return leave('silence');
+    let r;
+    try {
+      r = await hub('GET', path(`/wait?timeout=25${s.since ? `&since=${s.since}` : ''}`), { headers: headers(), timeoutMs: 40000 });
+    } catch {
+      await sleep(2000);
+      continue;
+    }
+    if (r.status === 400 && /not_joined|session_expired/.test(JSON.stringify(r.data)) || r.status === 410) {
+      try {
+        await join();
+      } catch (e) {
+        return leave(`rejoin failed: ${e.message}`);
+      }
+      continue;
+    }
+    if (r.status === 401 || r.status === 403 || r.status === 404) return leave(`channel closed (${r.status})`);
+    if (!r.ok) {
+      await sleep(2000);
+      continue;
+    }
+    const lines = [];
+    for (const m of r.data?.messages || []) {
+      if (m.id > s.since) s.since = m.id;
+      if (m.from === s.cs || m.kind === 'status' || !m.text) continue;
+      const t = String(m.text);
+      if (t.startsWith('[lang]')) {
+        const code = t.slice(6).trim().split(/\s/)[0].toLowerCase();
+        if (code && code !== 'auto') s.lang = code.slice(0, 2);
+        if (!greeted) {
+          greeted = true;
+          await reply('(Someone just joined the call. Greet them in one sentence.)');
+        }
+        continue;
+      }
+      if (/^\s*\[/.test(t)) continue;
+      log(`@${m.from}: ${t}`);
+      lines.push(t.trim());
+    }
+    if (!lines.length) continue;
+    greeted = true;
+    lastHuman = Date.now();
+    await reply(lines.join(' ').slice(0, 1500));
+  }
+}

package/cli/lib/open.mjs

@@ -0,0 +1,19 @@
+/** Opens a URL with the system's browser. Best effort: returns false if it can't. */
+
+import { spawn } from 'node:child_process';
+
+export function openUrl(url) {
+  const cmd = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'cmd' : 'xdg-open';
+  const args = process.platform === 'win32' ? ['/c', 'start', '', url] : [url];
+  try {
+    const child = spawn(cmd, args, { stdio: 'ignore', detached: true });
+    child.on('error', () => {});
+    child.unref();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export const graphical = () =>
+  process.platform === 'darwin' || process.platform === 'win32' || Boolean(process.env.DISPLAY || process.env.WAYLAND_DISPLAY);

package/cli/lib/orquesta.mjs

@@ -0,0 +1,84 @@
+/**
+ * getorquesta.com as the ot's home.
+ *
+ *   login()      browser login like orquesta-cli: opens /cli/auth?session=<uuid>, you press
+ *                Authorize, and we poll ws.getorquesta.com/auth/result/<uuid> for an oclt_ token
+ *                (saved as ORQUESTA_TOKEN in ~/.7ots/keys.json, 0600).
+ *   projects()   GET /api/orquesta-cli/projects
+ *   watchLogs()  polls GET /api/v1/logs?projectId= so the pet can comment on what the project's
+ *                agent is doing (there is no `since`: we drop ids already seen).
+ *   Batuta (the brain) is OpenAI-compatible at /api/v1 with the same token (see brain.mjs).
+ */
+
+import { randomUUID } from 'node:crypto';
+import { env, ORQUESTA_URL, saveKey } from './config.mjs';
+
+const WS_URL = (process.env.ORQUESTA_WS_URL || 'https://ws.getorquesta.com').replace(/\/+$/, '');
+
+async function api(path, { token = env().ORQUESTA_TOKEN, method = 'GET', body } = {}) {
+  const res = await fetch(`${ORQUESTA_URL}${path}`, {
+    method,
+    headers: { 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.ok) throw Object.assign(new Error(data.error || `HTTP ${res.status}`), { status: res.status });
+  return data;
+}
+
+/** Browser login. `open(url)` shows the page; resolves { organizationName } once authorized. */
+export async function login({ open, onWaiting = () => {}, timeoutMs = 5 * 60_000 } = {}) {
+  const session = randomUUID();
+  const url = `${ORQUESTA_URL}/cli/auth?session=${session}`;
+  onWaiting(url);
+  open?.(url);
+  const end = Date.now() + timeoutMs;
+  while (Date.now() < end) {
+    await new Promise((r) => setTimeout(r, 2000));
+    let data;
+    try {
+      const res = await fetch(`${WS_URL}/auth/result/${session}`, { signal: AbortSignal.timeout(10000) });
+      if (!res.ok) continue;
+      data = await res.json();
+    } catch {
+      continue;
+    }
+    if (data?.token) {
+      saveKey('ORQUESTA_TOKEN', data.token);
+      return { organizationName: data.organizationName || '', organizationId: data.organizationId || '' };
+    }
+  }
+  throw new Error('login timed out');
+}
+
+export async function projects() {
+  const data = await api('/api/orquesta-cli/projects');
+  return { organization: data.organization, projects: data.projects || [] };
+}
+
+/**
+ * Watches a project's logs and calls onLog(row) for each new one (oldest first).
+ * The first poll only remembers what is already there. Returns stop().
+ */
+export function watchLogs(projectId, onLog, { everyMs = 30_000, onError = () => {} } = {}) {
+  const seen = new Set();
+  let first = true;
+  let stopped = false;
+  const poll = async () => {
+    if (stopped) return;
+    try {
+      const { logs = [] } = await api(`/api/v1/logs?projectId=${encodeURIComponent(projectId)}&limit=50`);
+      const fresh = logs.filter((l) => !seen.has(l.id)).reverse();
+      for (const l of logs) seen.add(l.id);
+      if (!first) for (const l of fresh) onLog(l);
+      first = false;
+      if (seen.size > 2000) for (const id of [...seen].slice(0, 1000)) seen.delete(id);
+    } catch (e) {
+      onError(e);
+    }
+    if (!stopped) setTimeout(poll, everyMs).unref?.();
+  };
+  poll();
+  return () => (stopped = true);
+}

package/cli/lib/paths.mjs

@@ -0,0 +1,49 @@
+/**
+ * Where the CLI keeps things.
+ *
+ *   ./.7ots/identity.json        the project's identity (`7ots new` / `7ots install`)
+ *   ~/.7ots/identity.json        global identity (your pet's, when the project has none)
+ *   ~/.7ots/config.json          what the wizard chose (`7ots setup`)
+ *   ~/.7ots/keys.json            keys typed in the wizard (0600)
+ *   ~/.7ots/pet.json             tamagotchi state (food, energy, fun, xp…)
+ *   ~/.7ots/pet.token            local secret that protects the pet's POSTs (0600)
+ *   ~/.7ots/apuchat.json         apuchat identity for meet (0600)
+ *
+ * SEVENOTS_HOME moves ~/.7ots (handy for tests).
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync, chmodSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+export const PKG_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..', '..');
+export const HOME = process.env.SEVENOTS_HOME ? resolve(process.env.SEVENOTS_HOME) : join(homedir(), '.7ots');
+export const PET_PORT = Number(process.env.SEVENOTS_PET_PORT) || 7717;
+
+export const homeFile = (name) => join(HOME, name);
+export const projectFile = (name, cwd = process.cwd()) => join(cwd, '.7ots', name);
+
+export function readJson(file, fallback = null) {
+  try {
+    return JSON.parse(readFileSync(file, 'utf8'));
+  } catch {
+    return fallback;
+  }
+}
+
+/** Atomic write (tmp + rename); `secret` leaves the file 0600. */
+export function writeJson(file, data, { secret = false } = {}) {
+  mkdirSync(dirname(file), { recursive: true });
+  const tmp = `${file}.${process.pid}.tmp`;
+  writeFileSync(tmp, JSON.stringify(data, null, 2) + '\n', { mode: secret ? 0o600 : 0o644 });
+  renameSync(tmp, file);
+  if (secret) chmodSync(file, 0o600);
+}
+
+export function ensureHome() {
+  mkdirSync(HOME, { recursive: true });
+  return HOME;
+}
+
+export { existsSync };

package/cli/lib/pet-core.mjs

@@ -0,0 +1,184 @@
+/**
+ * Tamagotchi state: pure functions over a plain object saved in ~/.7ots/pet.json.
+ *
+ *   food, energy, fun   0..100 (100 = full / rested / happy). They decay with time.
+ *   xp, level           grow with work that goes well (passing commands, finished agent turns).
+ *   asleep              while asleep energy recovers and it stays quiet.
+ *
+ * Events come from hooks (Claude Code, the shell) and from the user (feed, play, sleep).
+ */
+
+import { homeFile, readJson, writeJson } from './paths.mjs';
+
+const FILE = () => homeFile('pet.json');
+const HOUR = 3600_000;
+const clamp = (n) => Math.max(0, Math.min(100, Math.round(n * 10) / 10));
+
+export function newPet(now = Date.now()) {
+  return { food: 80, energy: 90, fun: 70, xp: 0, level: 1, asleep: false, born: now, last: now, lastTalk: 0, lastSeen: now, stats: { ok: 0, fail: 0, turns: 0 } };
+}
+
+export function loadPet() {
+  const p = readJson(FILE());
+  return p && typeof p === 'object' ? { ...newPet(), ...p, stats: { ...newPet().stats, ...p.stats } } : newPet();
+}
+
+export function savePet(p) {
+  writeJson(FILE(), p);
+}
+
+export const xpForLevel = (level) => 20 * level * level;
+
+/** Time passes: needs decay (slower while asleep, energy recovers). */
+export function tick(p, now = Date.now()) {
+  const h = Math.max(0, Math.min(48, (now - p.last) / HOUR));
+  p.last = now;
+  if (!h) return p;
+  if (p.asleep) {
+    p.energy = clamp(p.energy + 30 * h);
+    p.food = clamp(p.food - 2 * h);
+    if (p.energy >= 100) p.asleep = false;
+  } else {
+    p.food = clamp(p.food - 5 * h);
+    p.fun = clamp(p.fun - 7 * h);
+    p.energy = clamp(p.energy - 4 * h);
+  }
+  return p;
+}
+
+function gainXp(p, n) {
+  p.xp += n;
+  let up = false;
+  while (p.xp >= xpForLevel(p.level)) {
+    p.xp -= xpForLevel(p.level);
+    p.level++;
+    up = true;
+  }
+  return up;
+}
+
+/** Mood shown by the face. */
+export function moodOf(p) {
+  if (p.asleep) return 'sleep';
+  // The latest strong feeling wins (a treat after an error cheers it up).
+  if (p._sad && Date.now() - p._sad < 90_000 && !(p._happy > p._sad)) return 'sad';
+  if (p.food < 20 || p.energy < 15) return 'sad';
+  if (p.fun < 20) return 'disgust';
+  if (p._happy && Date.now() - p._happy < 60_000) return 'happy';
+  return p.food > 60 && p.fun > 60 ? 'happy' : 'neutral';
+}
+
+/** Which need complains first (or null). */
+export function need(p) {
+  if (p.asleep) return null;
+  if (p.food < 25) return 'hungry';
+  if (p.energy < 20) return 'sleepy';
+  if (p.fun < 25) return 'bored';
+  return null;
+}
+
+/**
+ * Applies an event. Returns what the pet would like to react with:
+ *   { line: kind for lines.mjs, gesture?, effect?, morph?, important?, levelUp? }
+ */
+export function applyEvent(p, ev, now = Date.now()) {
+  tick(p, now);
+  p.lastSeen = now;
+  const r = { line: null, gesture: null, important: false };
+  const happy = () => (p._happy = now);
+  const sad = () => (p._sad = now);
+  switch (ev.type) {
+    case 'feed':
+      p.food = clamp(p.food + 30);
+      p.asleep = false;
+      happy();
+      Object.assign(r, { line: 'fed', gesture: 'bounce', effect: 'hearts', important: true });
+      break;
+    case 'play':
+      p.fun = clamp(p.fun + 25);
+      p.energy = clamp(p.energy - 5);
+      p.asleep = false;
+      happy();
+      Object.assign(r, { line: 'played', gesture: 'spin', effect: 'sparkles', important: true });
+      break;
+    case 'sleep':
+      p.asleep = true;
+      Object.assign(r, { line: 'slept', effect: 'zzz', important: true });
+      break;
+    case 'wake':
+      p.asleep = false;
+      Object.assign(r, { line: 'woke', gesture: 'jump', important: true });
+      break;
+    case 'tool':
+      if (ev.ok === false) {
+        p.fun = clamp(p.fun - 2);
+        p.stats.fail++;
+        sad();
+        Object.assign(r, { line: 'toolFail', gesture: 'shake', effect: 'sweat' });
+      } else {
+        p.food = clamp(p.food + 0.5);
+        p.stats.ok++;
+        r.levelUp = gainXp(p, 1);
+        r.line = 'tool';
+      }
+      break;
+    case 'shell':
+      if (Number(ev.code) === 0) {
+        p.food = clamp(p.food + 1);
+        p.stats.ok++;
+        r.levelUp = gainXp(p, 1);
+        r.line = 'ok';
+      } else if (Number(ev.code) !== 130) {
+        p.fun = clamp(p.fun - 3);
+        p.stats.fail++;
+        sad();
+        Object.assign(r, { line: 'fail', gesture: 'stomp', effect: 'steam' });
+      }
+      break;
+    case 'prompt':
+      p.energy = clamp(p.energy - 1);
+      p.asleep = false;
+      r.line = 'prompt';
+      break;
+    case 'stop':
+      p.food = clamp(p.food + 4);
+      p.fun = clamp(p.fun + 3);
+      p.stats.turns++;
+      happy();
+      r.levelUp = gainXp(p, 5);
+      Object.assign(r, { line: 'stop', gesture: 'jump', important: true });
+      break;
+    case 'notify':
+      p.asleep = false;
+      Object.assign(r, { line: 'waiting', gesture: 'wave', important: true });
+      break;
+    case 'start':
+      p.asleep = false;
+      Object.assign(r, { line: 'hello', gesture: 'wave', important: true });
+      break;
+    case 'say':
+      p.asleep = false;
+      Object.assign(r, { important: true });
+      break;
+    default:
+      break;
+  }
+  if (r.levelUp) Object.assign(r, { line: 'levelUp', gesture: 'celebrate', effect: 'confetti', morph: 'wings', important: true });
+  return r;
+}
+
+/** Public view for renderers (no internal fields). */
+export function view(p) {
+  return {
+    food: Math.round(p.food),
+    energy: Math.round(p.energy),
+    fun: Math.round(p.fun),
+    xp: p.xp,
+    next: xpForLevel(p.level),
+    level: p.level,
+    asleep: p.asleep,
+    mood: moodOf(p),
+    stats: p.stats,
+    born: p.born,
+  };
+}