@7ots/cli 0.1.5 → 0.1.6

package/cli/lib/integrations.mjs

@@ -0,0 +1,414 @@
+/**
+ * What the ot can reach beyond reminders and notes (settings → Permissions → Integrations), and
+ * its character sheet (settings → Personality).
+ *
+ *   config.integrations
+ *     orquesta { on, projectId?, projectName? }   talk to your Orquesta agents (ORQUESTA_TOKEN): list them, send a message,
+ *                                                 and it tells you what the agent answered when it finishes
+ *     apumail  { on, inbox }                      read your email (APUMAIL_TOKEN) — also needs access.inbox
+ *     custom   [{ id, name, instructions, url?, command?, envVar?, on }]
+ *              told to the brain; with a url (GET, Bearer $envVar) or a command (/bin/sh -c, 20 s) it can fetch it
+ *   access.logs   it may read the logs of running processes: journal (systemd unit), pm2, docker, a log file,
+ *                 or a running process (its stdout file, else its journal). Secrets are redacted, ~80 lines.
+ *   config.character { backstory, style, quirks, examples, scenario, greeting, letta?: { on, agentId } }
+ *              a chara_card_v2-style sheet; it weighs more than the identity's traits in every prompt.
+ *              With Letta (LETTA_API_KEY) the persona lives in a Letta agent's memory too, and what Letta
+ *              remembers (persona + human blocks) comes back into the prompt.
+ *   cloudStatus()  link with 7ots.com (account.mjs) + the cloud assistant's VM: GET /api/device/ots/:id/vm (device token; see docs/VM-PLAN.md)
+ *                  (404 = not available yet).
+ *
+ * Extra assistant actions (assistant.mjs `extra`): read_logs · read_mail · orquesta_list · orquesta · integration.
+ */
+
+import { spawn } from 'node:child_process';
+import { randomBytes } from 'node:crypto';
+import { closeSync, openSync, readSync, readlinkSync, realpathSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { env, loadConfig, loadKeys } from './config.mjs';
+import { SEVENOTS_URL, me as accountMe, signedIn } from './account.mjs';
+
+const LETTA_URL = (process.env.LETTA_BASE_URL || 'https://api.letta.com').replace(/\/+$/, '');
+const APUMAIL_API = (process.env.APUMAIL_API || 'https://api.apumail.com').replace(/\/+$/, '');
+const MAX_OUT = 4000;
+
+const str = (v, max) => String(v ?? '').replace(/\r/g, '').trim().slice(0, max);
+const bool = (v, d = false) => (typeof v === 'boolean' ? v : d);
+
+// ── secrets never reach the brain ──
+export function redact(s) {
+  return String(s ?? '')
+    .replace(/(--?[\w-]*(?:token|key|secret|pass(?:word)?|auth)[\w-]*[= ])\S+/gi, '$1***')
+    .replace(/\b([A-Z0-9_]*(?:TOKEN|KEY|SECRET|PASSWORD|PASS|AUTH)[A-Z0-9_]*\s*[=:]\s*)\S+/g, '$1***')
+    .replace(/("(?:[\w-]*(?:token|key|secret|password|authorization)[\w-]*)"\s*:\s*")[^"]*"/gi, '$1***"')
+    .replace(/\b(Bearer|Basic)\s+[A-Za-z0-9._~+/=-]{8,}/gi, '$1 ***')
+    .replace(/\b(sk|pk|rk|ghp|gho|ghs|xox[abpr]|oclt|oek|7d|7vm|7ve)[-_][A-Za-z0-9_-]{8,}/g, '$1_***')
+    .replace(/\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]+/g, 'jwt_***')
+    .replace(/(\/\/[^/\s:@]+:)[^@\s]+@/g, '$1***@');
+}
+
+// ── settings: validation ──
+
+export function normalizeCharacter(d = {}, prev = {}) {
+  const out = { ...prev };
+  for (const [k, max] of [['backstory', 3000], ['style', 1500], ['quirks', 1500], ['examples', 4000], ['scenario', 1500], ['greeting', 600]]) if (d[k] !== undefined) out[k] = str(d[k], max);
+  if (d.letta) {
+    const agentId = str(d.letta.agentId ?? prev.letta?.agentId, 80);
+    if (agentId && !/^[\w-]{1,80}$/.test(agentId)) throw new Error('lettaAgent');
+    out.letta = { on: bool(d.letta.on, !!prev.letta?.on), ...(agentId ? { agentId } : {}) };
+  }
+  return out;
+}
+
+export function normalizeIntegrations(d = {}, prev = {}) {
+  const out = { orquesta: { ...prev.orquesta }, apumail: { ...prev.apumail }, custom: [...(prev.custom || [])] };
+  if (d.orquesta) {
+    const o = d.orquesta;
+    const projectId = o.projectId === undefined ? out.orquesta.projectId : str(o.projectId, 80);
+    if (projectId && !/^[\w-]{1,80}$/.test(projectId)) throw new Error('project');
+    out.orquesta = { on: bool(o.on, !!out.orquesta.on), ...(projectId ? { projectId, projectName: str(o.projectName ?? out.orquesta.projectName, 120) } : {}) };
+  }
+  if (d.apumail) {
+    const inbox = d.apumail.inbox === undefined ? out.apumail.inbox || '' : str(d.apumail.inbox, 120).toLowerCase();
+    if (inbox && !/^[^\s@/]+@[^\s@/]+\.[^\s@/]{2,}$/.test(inbox)) throw new Error('inbox');
+    out.apumail = { on: bool(d.apumail.on, !!out.apumail.on), inbox };
+  }
+  if (Array.isArray(d.custom)) {
+    if (d.custom.length > 20) throw new Error('custom');
+    out.custom = d.custom.map((c) => {
+      const name = str(c?.name, 60);
+      if (!name) throw new Error('customName');
+      const url = str(c.url, 300);
+      if (url && !/^https?:\/\/[^\s"'<>]+$/i.test(url)) throw new Error('customUrl');
+      const envVar = str(c.envVar, 64);
+      if (envVar && !/^[A-Z][A-Z0-9_]{1,63}$/.test(envVar)) throw new Error('customEnv');
+      const id = /^[\w-]{1,40}$/.test(c.id || '') ? c.id : randomBytes(4).toString('hex');
+      return { id, name, instructions: str(c.instructions, 1500), ...(url ? { url } : {}), ...(c.command ? { command: str(c.command, 500) } : {}), ...(envVar ? { envVar } : {}), on: bool(c.on, true) };
+    });
+  }
+  return out;
+}
+
+// ── what goes into the system prompt ──
+
+const lettaCache = { at: 0, agentId: '', text: '', busy: false };
+
+/** The character sheet as prompt text ('' when empty). */
+export function characterPrompt(ch = {}) {
+  if (!ch || typeof ch !== 'object') return '';
+  const parts = [
+    ch.backstory && `Backstory: ${ch.backstory}`,
+    ch.style && `How you speak: ${ch.style}`,
+    ch.quirks && `Quirks: ${ch.quirks}`,
+    ch.scenario && `Scenario: ${ch.scenario}`,
+    ch.examples && `Example dialogues (for your voice only; never repeat them word for word):\n${ch.examples}`,
+  ].filter(Boolean);
+  if (ch.letta?.on && ch.letta.agentId) {
+    refreshLetta(ch.letta.agentId);
+    if (lettaCache.agentId === ch.letta.agentId && lettaCache.text) parts.push(lettaCache.text);
+  }
+  if (!parts.length) return '';
+  return `YOUR CHARACTER SHEET — this matters more than the traits above; stay true to it:\n${parts.join('\n')}`;
+}
+
+/** Custom integrations the human described (assistant prompts only). */
+export function integrationsPrompt(config = {}) {
+  const custom = (config.integrations?.custom || []).filter((c) => c.on !== false);
+  if (!custom.length) return '';
+  return `Integrations your human set up for you:\n${custom.map((c) => `- ${c.name} (id ${c.id})${c.instructions ? `: ${c.instructions}` : ''}`).join('\n')}`;
+}
+
+// ── logs of running processes (access.logs) ──
+
+const NAME_RE = /^[\w@.:+-]{1,80}$/;
+const SENSITIVE = /(\/\.ssh\/|\/\.gnupg\/|\/\.aws\/|\/\.config\/gcloud\/|keys\.json|\.env(\.|$)|credential|secret|token|llaves|\.pem$|\.key$|\.p8$|id_[rd]sa|shadow$|\.kdbx$)/i;
+
+function exec(bin, args, { timeoutMs = 10000, max = 64000 } = {}) {
+  return new Promise((resolve) => {
+    let out = '';
+    let child;
+    try {
+      child = spawn(bin, args, { stdio: ['ignore', 'pipe', 'pipe'], env: { ...process.env, NO_COLOR: '1', PAGER: 'cat' } });
+    } catch (e) {
+      return resolve({ ok: false, out: e.message });
+    }
+    const timer = setTimeout(() => child.kill('SIGTERM'), timeoutMs);
+    const take = (d) => {
+      out += d;
+      if (out.length > max) (out = out.slice(-max)), child.kill('SIGTERM');
+    };
+    child.stdout.on('data', take);
+    child.stderr.on('data', take);
+    child.on('error', (e) => (clearTimeout(timer), resolve({ ok: false, out: e.code === 'ENOENT' ? `${bin} is not installed` : e.message })));
+    child.on('close', (code) => (clearTimeout(timer), resolve({ ok: code === 0, out })));
+  });
+}
+
+function tailFile(file, bytes = 16000) {
+  const real = realpathSync(file.replace(/^~(?=\/)/, homedir()));
+  if (SENSITIVE.test(real)) throw new Error('that file is private');
+  const st = statSync(real);
+  if (!st.isFile()) throw new Error('not a file');
+  const fd = openSync(real, 'r');
+  try {
+    const len = Math.min(bytes, st.size);
+    const buf = Buffer.alloc(len);
+    readSync(fd, buf, 0, len, st.size - len);
+    return buf.toString('utf8').split('\n').slice(len < st.size ? 1 : 0).join('\n');
+  } finally {
+    closeSync(fd);
+  }
+}
+
+const lastLines = (s, n = 80) => String(s).trimEnd().split('\n').slice(-n).join('\n');
+
+/** The last lines of a process's logs. source: journal | pm2 | docker | file | process. */
+export async function readLogs({ source, target }) {
+  const t = String(target || '').trim();
+  let text;
+  if (source === 'file') {
+    if (!/^(~|\/)[^\0]{1,300}$/.test(t) || !/(\.log(\.\d+)?|\.out|\.err|\.txt)$|\/log(s)?\//i.test(t)) throw new Error('only log files (*.log, …/logs/…)');
+    text = tailFile(t);
+  } else if (source === 'journal') {
+    if (!NAME_RE.test(t)) throw new Error('bad unit');
+    let r = await exec('journalctl', ['--user', '-u', t, '-n', '80', '--no-pager', '-o', 'short-iso']);
+    if (!r.ok || /No entries/i.test(r.out)) r = await exec('journalctl', ['-u', t, '-n', '80', '--no-pager', '-o', 'short-iso']);
+    text = r.out;
+  } else if (source === 'pm2') {
+    if (!NAME_RE.test(t)) throw new Error('bad name');
+    text = (await exec('pm2', ['logs', t, '--lines', '80', '--nostream', '--raw'])).out;
+  } else if (source === 'docker') {
+    if (!NAME_RE.test(t)) throw new Error('bad container');
+    text = (await exec('docker', ['logs', '--tail', '80', '--timestamps', t])).out;
+  } else if (source === 'process') {
+    if (!/^[\w .@:/=+-]{1,80}$/.test(t)) throw new Error('bad process');
+    const pids = (await exec('pgrep', ['-f', '--', t])).out.split('\n').map(Number).filter((p) => p && p !== process.pid).slice(0, 3);
+    if (!pids.length) throw new Error(`no running process matches "${t}"`);
+    for (const pid of pids) {
+      for (const fd of [1, 2]) {
+        try {
+          const f = readlinkSync(`/proc/${pid}/fd/${fd}`);
+          if (f.startsWith('/') && !f.startsWith('/dev/')) {
+            text = tailFile(f);
+            break;
+          }
+        } catch {}
+      }
+      if (text) break;
+    }
+    if (!text) text = (await exec('journalctl', ['_PID=' + pids[0], '-n', '80', '--no-pager', '-o', 'short-iso'])).out;
+    if (!text.trim() || /No entries/i.test(text)) throw new Error(`"${t}" writes to a terminal; there is no log to read`);
+  } else throw new Error('unknown log source');
+  return redact(lastLines(text)).slice(-MAX_OUT);
+}
+
+// ── email (apumail) ──
+
+export async function readMail(inbox, { n = 8 } = {}) {
+  const token = env().APUMAIL_TOKEN;
+  if (!token || !inbox) throw new Error('email is not connected');
+  const res = await fetch(`${APUMAIL_API}/api/v1/inbox/${encodeURIComponent(inbox)}/wait?timeout=1`, { headers: { Authorization: `Bearer ${token}` }, signal: AbortSignal.timeout(15000) });
+  if (!res.ok) throw new Error(`apumail ${res.status}`);
+  const { messages = [] } = await res.json();
+  return messages
+    .slice(-n)
+    .reverse()
+    .map((m) => `- ${new Date(Number(m.received_at) || m.received_at).toLocaleString()} · ${str(m.from, 120)} · ${str(m.subject, 160) || '(no subject)'}\n  ${str(m.text, 300).replace(/\s+/g, ' ')}`)
+    .join('\n');
+}
+
+// ── custom integrations ──
+
+async function runCustom(c) {
+  if (c.url) {
+    const tok = c.envVar ? process.env[c.envVar] || loadKeys()[c.envVar] : '';
+    const res = await fetch(c.url, { headers: { Accept: 'application/json, text/plain;q=0.9, */*;q=0.5', ...(tok ? { Authorization: `Bearer ${tok}` } : {}) }, signal: AbortSignal.timeout(15000) });
+    const body = (await res.text()).slice(0, 20000);
+    return redact(`HTTP ${res.status}\n${body}`).slice(0, MAX_OUT);
+  }
+  if (c.command) {
+    const r = await exec('/bin/sh', ['-c', c.command], { timeoutMs: 20000 });
+    return redact(lastLines(r.out, 120)).slice(-MAX_OUT);
+  }
+  return '';
+}
+
+// ── 7ots.com: link and cloud assistant ──
+
+export async function cloudStatus(config = loadConfig()) {
+  const out = { url: SEVENOTS_URL, signedIn: signedIn(), current: config.account || null, vm: { status: 'soon' } };
+  if (!out.signedIn) return out;
+  try {
+    const m = await accountMe();
+    const acc = m.account || {};
+    out.user = { name: str(acc.name || acc.email, 80), email: str(acc.email, 120) };
+    const twin = (m.ots || []).find((o) => o.id === config.account?.otsId);
+    if (twin) out.twin = { id: twin.id, name: str(twin.name, 60) };
+  } catch (e) {
+    out.error = e.message;
+    if (e.status === 401) out.signedIn = false;
+  }
+  const id = config.account?.otsId;
+  if (!id || !out.signedIn) return out;
+  try {
+    const res = await fetch(`${SEVENOTS_URL}/api/device/ots/${encodeURIComponent(id)}/vm`, { headers: { Authorization: `Bearer ${env().SEVENOTS_TOKEN}` }, signal: AbortSignal.timeout(10000) });
+    if (res.ok) {
+      const v = await res.json().catch(() => ({}));
+      const vm = v.vm || v;
+      out.vm = { status: str(vm.status || 'unknown', 40), ...(vm.region ? { region: str(vm.region, 40) } : {}), ...(vm.since || vm.createdAt ? { since: vm.since || vm.createdAt } : {}) };
+    } else out.vm = { status: [404, 405, 501].includes(res.status) ? 'soon' : res.status === 401 || res.status === 403 ? 'denied' : 'error' };
+  } catch {
+    out.vm = { status: 'error' };
+  }
+  return out;
+}
+
+// ── Letta (persona memory) ──
+// Contract (docs.letta.com): Bearer LETTA_API_KEY
+//   POST  /v1/agents { name, memory_blocks: [{ label, value }], model, embedding } → { id }
+//   GET   /v1/agents/:id/core-memory/blocks/:label → { value }
+//   PATCH /v1/agents/:id/core-memory/blocks/:label { value }
+
+async function letta(path, { method = 'GET', body } = {}) {
+  const key = env().LETTA_API_KEY;
+  if (!key) throw Object.assign(new Error('LETTA_API_KEY is missing'), { status: 400 });
+  const res = await fetch(`${LETTA_URL}${path}`, { method, headers: { Authorization: `Bearer ${key}`, ...(body ? { 'Content-Type': 'application/json' } : {}) }, body: body ? JSON.stringify(body) : undefined, signal: AbortSignal.timeout(20000) });
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) throw Object.assign(new Error(`Letta ${res.status}${data.detail ? `: ${String(typeof data.detail === 'string' ? data.detail : JSON.stringify(data.detail)).slice(0, 160)}` : ''}`), { status: res.status });
+  return data;
+}
+
+const personaText = (identity, ch) => [`I am ${identity.name}, a 7ots desktop ot.`, ch.backstory, ch.style && `I speak like this: ${ch.style}`, ch.quirks && `Quirks: ${ch.quirks}`].filter(Boolean).join('\n').slice(0, 4500);
+
+/** Writes the sheet into Letta's persona block (creates the agent the first time). Returns { agentId, created }. */
+export async function lettaSync(identity, ch = {}) {
+  const value = personaText(identity, ch);
+  if (ch.letta?.agentId) {
+    await letta(`/v1/agents/${encodeURIComponent(ch.letta.agentId)}/core-memory/blocks/persona`, { method: 'PATCH', body: { value } });
+    lettaCache.at = 0;
+    return { agentId: ch.letta.agentId, created: false };
+  }
+  const a = await letta('/v1/agents', { method: 'POST', body: { name: `7ots-${String(identity.name).replace(/[^\w-]/g, '').slice(0, 30) || 'ot'}`, memory_blocks: [{ label: 'persona', value }, { label: 'human', value: 'My human, who keeps me on their computer.' }], model: process.env.LETTA_MODEL || 'openai/gpt-4o-mini', embedding: process.env.LETTA_EMBEDDING || 'openai/text-embedding-3-small' } });
+  if (!a.id) throw new Error('Letta did not return an agent id');
+  return { agentId: String(a.id), created: true };
+}
+
+function refreshLetta(agentId) {
+  if (lettaCache.busy || (lettaCache.agentId === agentId && Date.now() - lettaCache.at < 10 * 60_000) || !env().LETTA_API_KEY) return;
+  lettaCache.busy = true;
+  const block = (l) => letta(`/v1/agents/${encodeURIComponent(agentId)}/core-memory/blocks/${l}`).then((b) => str(b.value, 2000), () => '');
+  Promise.all([block('persona'), block('human')])
+    .then(([persona, human]) => {
+      lettaCache.agentId = agentId;
+      lettaCache.text = [persona && `Your persona as Letta remembers it: ${persona}`, human && `What Letta remembers about your human: ${human}`].filter(Boolean).join('\n');
+    })
+    .finally(() => ((lettaCache.at = Date.now()), (lettaCache.busy = false)));
+}
+
+// ── extra assistant actions ──
+
+/**
+ * @param {{ config: () => object, brain: object, system: (lang) => string, onLater: (line: string) => void, log?: Function }} o
+ *   onLater  an Orquesta agent answered (or failed) after the reply: say it
+ */
+export function createExtras({ config, brain, system, onLater, log = () => {} }) {
+  let projCache = { at: 0, list: [] };
+  const orq = () => import('./orquesta.mjs');
+  const orqOn = () => config().integrations?.orquesta?.on && Boolean(env().ORQUESTA_TOKEN);
+  const mailOn = () => config().access?.inbox === true && config().integrations?.apumail?.on && config().integrations.apumail.inbox && Boolean(env().APUMAIL_TOKEN);
+  const customs = () => (config().integrations?.custom || []).filter((c) => c.on !== false && (c.url || c.command));
+
+  async function projects() {
+    if (Date.now() - projCache.at < 5 * 60_000 && projCache.list.length) return projCache.list;
+    projCache = { at: Date.now(), list: await (await orq()).agentProjects() };
+    return projCache.list;
+  }
+
+  async function follow(id, project, lang) {
+    const { agentTask } = await orq();
+    const end = Date.now() + 30 * 60_000;
+    while (Date.now() < end) {
+      await new Promise((r) => setTimeout(r, 10_000));
+      let t;
+      try {
+        t = await agentTask(id);
+      } catch (e) {
+        log(`orquesta: ${e.message}`);
+        continue;
+      }
+      if (!['completed', 'failed', 'cancelled'].includes(t.status)) continue;
+      let line = `${project}: ${t.status === 'completed' ? cut(t.result || 'done', 240) : t.error || t.status}`;
+      if (t.status === 'completed' && t.result && brain.kind !== 'lines') {
+        try {
+          const said = await brain.think({ purpose: 'assistant', system: system(lang), messages: [{ role: 'user', content: `Your human asked their Orquesta agent in project "${project}" for something and it just finished. Its answer:\n"""${redact(t.result).slice(-3000)}"""\nTell your human in 1-2 short sentences what it did or answered, in character.` }], timeoutMs: 45000 });
+          if (said) line = said;
+        } catch {}
+      }
+      return onLater(line);
+    }
+  }
+
+  return {
+    /** Action docs for the assistant prompt (only what is on). */
+    prompt() {
+      const c = config();
+      const lines = [];
+      if (c.access?.logs === true) lines.push(`{"type":"read_logs","source":"journal|pm2|docker|file|process","target":"unit / pm2 app / container / path to a .log file / part of a running command"} (read the last lines of a program's logs, then you explain them)`);
+      if (mailOn()) lines.push(`{"type":"read_mail"} (read the latest emails in their inbox ${c.integrations.apumail.inbox}, then you sum them up)`);
+      if (orqOn()) {
+        const def = c.integrations.orquesta.projectName ? ` (default project: "${c.integrations.orquesta.projectName}")` : '';
+        lines.push(`{"type":"orquesta_list"} (list their Orquesta projects and whether each agent is online) · {"type":"orquesta","project":"name or id, or null for the default","text":"the message for that project's coding agent"}${def} (send a task or question to one of their Orquesta agents; you tell them the answer when it finishes)`);
+      }
+      for (const x of customs()) lines.push(`{"type":"integration","id":"${x.id}"} (fetch "${x.name}")`);
+      return lines.length ? `More actions you have:\n${lines.join('\n')}` : '';
+    },
+    /** A raw AI action → a validated one, or null. */
+    parse(a) {
+      if (a?.type === 'read_logs' && ['journal', 'pm2', 'docker', 'file', 'process'].includes(a.source) && a.target) return { type: 'read_logs', extra: true, source: a.source, target: String(a.target).slice(0, 300) };
+      if (a?.type === 'read_mail') return { type: 'read_mail', extra: true };
+      if (a?.type === 'orquesta_list') return { type: 'orquesta_list', extra: true };
+      if (a?.type === 'orquesta' && a.text) return { type: 'orquesta', extra: true, project: a.project ? String(a.project).slice(0, 120) : null, text: String(a.text).slice(0, 4000) };
+      if (a?.type === 'integration' && a.id) return { type: 'integration', extra: true, id: String(a.id).slice(0, 40) };
+      return null;
+    },
+    /** Runs one: { say?, data? }. data goes back to the brain for the final reply. Never throws. */
+    async run(a, lang) {
+      const c = config();
+      try {
+        if (a.type === 'read_logs') {
+          if (c.access?.logs !== true) return { data: '(you are not allowed to read logs: settings → Permissions)' };
+          return { data: `Logs (${a.source} ${a.target}):\n${await readLogs(a)}` };
+        }
+        if (a.type === 'read_mail') {
+          if (!mailOn()) return { data: '(email is not connected or not allowed: settings → Permissions)' };
+          return { data: `Latest emails:\n${(await readMail(c.integrations.apumail.inbox)) || '(none)'}` };
+        }
+        if (a.type === 'orquesta_list') {
+          if (!orqOn()) return { data: '(Orquesta is not connected)' };
+          const ps = await projects();
+          return { data: `Orquesta projects:\n${ps.map((p) => `- ${p.name} (id ${p.id}) agent ${p.online === null ? 'unknown' : p.online ? 'online' : 'offline'}`).join('\n') || '(none)'}` };
+        }
+        if (a.type === 'orquesta') {
+          if (!orqOn()) return { data: '(Orquesta is not connected)' };
+          const ps = await projects();
+          const want = String(a.project || '').toLowerCase();
+          const p = want ? ps.find((x) => x.id === a.project) || ps.find((x) => x.name.toLowerCase() === want) || ps.find((x) => x.name.toLowerCase().includes(want)) : ps.find((x) => x.id === c.integrations.orquesta.projectId) || (ps.length === 1 ? ps[0] : null);
+          if (!p) return { data: `(which project? ${ps.map((x) => x.name).join(', ')})` };
+          const { sendToAgent } = await orq();
+          const { id } = await sendToAgent(p.id, a.text);
+          follow(id, p.name, lang).catch((e) => log(`orquesta: ${e.message}`));
+          return { data: `Sent to the agent of "${p.name}"${p.online === false ? ' (its agent is offline now; it runs when it comes back)' : ''}. Tell them you'll let them know when it answers.` };
+        }
+        if (a.type === 'integration') {
+          const x = customs().find((y) => y.id === a.id);
+          if (!x) return { data: '(that integration is off or does not exist)' };
+          return { data: `${x.name}:\n${(await runCustom(x)) || '(empty)'}` };
+        }
+      } catch (e) {
+        return { data: `(${a.type} failed: ${redact(e.message).slice(0, 200)})` };
+      }
+      return {};
+    },
+  };
+}
+
+const cut = (s, n) => (s.length > n ? `${s.slice(0, n - 1)}…` : s);

package/cli/lib/orquesta.mjs

@@ -7,6 +7,7 @@
  *   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).
+ *   agentProjects() · sendToAgent() · agentTask()   talk to the projects' agents (integrations.mjs)
  *   Batuta (the brain) is OpenAI-compatible at /api/v1 with the same token (see brain.mjs).
  */
 
@@ -82,3 +83,55 @@ export function watchLogs(projectId, onLog, { everyMs = 30_000, onError = () =>
   poll();
   return () => (stopped = true);
 }
+
+// ── talking to the user's Orquesta agents (the same /api/v1 the 7ots.com platform uses) ──
+//   GET  /api/v1/projects → { projects: [{ id, name, agentOnline, agentLastSeen }] }   (oclt_ CLI tokens: /api/orquesta-cli/projects)
+//   POST /api/v1/prompts { projectId, content, context, tags, source:'api' } → 201 { prompt: { id } }
+//        400 AGENT_NOT_CONFIGURED when the project has no agent
+//   GET  /api/v1/prompts/:id → { prompt: { status, result?, error } }
+//   GET  /api/v1/logs?promptId=&afterSequence= → { logs: [{ category, message, sequence }] }  (text in 'output')
+
+const FINAL = ['completed', 'failed', 'cancelled'];
+
+/** Projects the token reaches, with whether their agent is online. */
+export async function agentProjects() {
+  let data;
+  try {
+    data = await api('/api/v1/projects');
+  } catch (e) {
+    if (![401, 403, 404].includes(e.status)) throw e;
+    data = await api('/api/orquesta-cli/projects');
+  }
+  return (data.projects || []).slice(0, 200).map((p) => ({ id: String(p.id), name: String(p.name || p.slug || p.id).slice(0, 120), online: p.agentOnline == null ? null : !!p.agentOnline }));
+}
+
+/** Hands a message to a project's agent. Returns { id }. */
+export async function sendToAgent(projectId, content, { context = '7ots desktop ot' } = {}) {
+  try {
+    const data = await api('/api/v1/prompts', { method: 'POST', body: { projectId, content: String(content).slice(0, 4000), context: String(context).slice(0, 500), tags: ['7ots', 'desktop'], source: 'api' } });
+    const id = data.prompt?.id;
+    if (!id) throw new Error('no prompt id');
+    return { id: String(id) };
+  } catch (e) {
+    if (/AGENT_NOT_CONFIGURED/i.test(e.message)) throw Object.assign(new Error('this project has no agent connected'), { status: 400 });
+    throw e;
+  }
+}
+
+/** Where a message to an agent is: { status, result?, error? } (the agent's output once it finished). */
+export async function agentTask(id) {
+  const { prompt: p = {} } = await api(`/api/v1/prompts/${encodeURIComponent(id)}`);
+  const status = String(p.status || 'pending');
+  if (!FINAL.includes(status)) return { status };
+  if (status !== 'completed') return { status, error: String(p.error || status).slice(0, 500) };
+  if (typeof p.result === 'string' && p.result.trim()) return { status, result: p.result.trim().slice(0, 8000) };
+  const out = [];
+  let after = null;
+  for (let page = 0; page < 5; page++) {
+    const { logs = [] } = await api(`/api/v1/logs?${new URLSearchParams({ promptId: id, ...(after != null ? { afterSequence: String(after) } : {}) })}`).catch(() => ({}));
+    for (const l of logs) if (l.category === 'output' && l.message) out.push(String(l.message));
+    if (logs.length < 50) break;
+    after = logs.at(-1).sequence;
+  }
+  return { status, result: out.join('\n').trim().slice(-8000) };
+}

package/cli/lib/pet-core.mjs

@@ -3,7 +3,8 @@
  *
  *   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.
+ *   asleep              while asleep energy recovers and it stays quiet. It sleeps until you wake it
+ *                       (wake, feed, play); urgent things only stir it (r.stir) and it dozes off again.
  *
  * Events come from hooks (Claude Code, the shell) and from the user (feed, play, sleep).
  */
@@ -38,7 +39,6 @@ export function tick(p, now = Date.now()) {
   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);
@@ -89,8 +89,9 @@ export function applyEvent(p, ev, now = Date.now()) {
   const happy = () => (p._happy = now);
   const sad = () => (p._sad = now);
   switch (ev.type) {
-    case 'feed':
+    case 'feed': // one "treat" button: food and fun together
       p.food = clamp(p.food + 30);
+      p.fun = clamp(p.fun + 20);
       p.asleep = false;
       happy();
       Object.assign(r, { line: 'fed', gesture: 'bounce', effect: 'hearts', important: true });
@@ -138,7 +139,6 @@ export function applyEvent(p, ev, now = Date.now()) {
       break;
     case 'prompt':
       p.energy = clamp(p.energy - 1);
-      p.asleep = false;
       r.line = 'prompt';
       break;
     case 'stop':
@@ -147,19 +147,16 @@ export function applyEvent(p, ev, now = Date.now()) {
       p.stats.turns++;
       happy();
       r.levelUp = gainXp(p, 5);
-      Object.assign(r, { line: 'stop', gesture: 'jump', important: true });
+      Object.assign(r, { line: 'stop', gesture: 'jump', important: true, stir: p.asleep }); // background work finished
       break;
     case 'notify':
-      p.asleep = false;
-      Object.assign(r, { line: 'waiting', gesture: 'wave', important: true });
+      Object.assign(r, { line: 'waiting', gesture: 'wave', important: true, stir: p.asleep });
       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 });
+      Object.assign(r, { important: true, stir: p.asleep });
       break;
     default:
       break;