nio-cat 0.9.6 → 0.9.9

package/README.md

@@ -14,6 +14,7 @@ Instal·la nio i `cloudflared` al teu usuari, el deixa com a servei (systemd o l
 
 - **Sessions** de Claude Code i Codex en directe, a qualsevol dels teus ordinadors.
 - **Aprovacions** amb el motiu, al mòbil, al push o a Telegram, i **registre** de totes les accions (`~/.nio/audit.jsonl`).
+- **Notes** com Google Keep: targetes, llistes, colors i etiquetes. Grava amb el mòbil i Whisper les transcriu a l’ordinador. Un model local (Ollama), Claude Code o Codex les resumeix i les organitza. Es desen a `~/.nio/notes`.
 - **Feines**: cua, cadenes («quan acabi, que Codex ho revisi») i programació (cron).
 - **Memòria compartida** a `~/.nio/memory`, amb un servidor MCP (`nio mcp`) registrat a Claude Code i Codex.
 - **Telegram** (el teu bot) i **veu**: dictat gratis amb Whisper a l’ordinador (whisper.cpp + ffmpeg; l’àudio no en surt), o ElevenLabs i OpenAI amb les teves claus.

package/bin/nio.js

@@ -7,13 +7,15 @@ const crypto = require('crypto');
 const { spawn } = require('child_process');
 const config = require('../src/config');
 const { Hub } = require('../src/hub');
-const { createServer } = require('../src/server');
+const { createServer, listProjects } = require('../src/server');
 const { detectAll } = require('../src/agents');
 const { startTunnel, startNamedTunnel, startConfiguredTunnel, setupNamedTunnel } = require('../src/tunnel');
 const service = require('../src/service');
 const { Auth } = require('../src/auth');
 const { Audit } = require('../src/audit');
 const memory = require('../src/memory');
+const { Notes } = require('../src/notes');
+const { Call } = require('../src/call');
 const mcp = require('../src/mcp');
 const directory = require('../src/directory');
 const voice = require('../src/voice');
@@ -213,7 +215,9 @@ async function start() {
   if (cfg.telegram?.token) row('Telegram', 'actiu', `(${(cfg.telegram.allowed || []).length} xats autoritzats)`);
   const control = new Control({ cfg, hub, audit });
   const remote = new Remote({ cfg, audit });
-  const routes = [...memory.routes(), ...jobs.routes(), ...voice.routes(cfg), ...tg.routes(), ...control.routes(), ...remote.routes()];
+  const notes = new Notes({ cfg, hub });
+  const call = new Call({ cfg, hub, audit, projects: () => listProjects(cfg), hookUrl: jobs.hookUrl, terminal: () => require('../src/terminal').listSessions(require('../src/agents').binPath(cfg, 'claude'), require('../src/proc').childEnv()) });
+  const routes = [...memory.routes(), ...notes.routes(), ...call.routes(), ...jobs.routes(), ...voice.routes(cfg), ...tg.routes(), ...control.routes(), ...remote.routes()];
   const server = createServer({ cfg, hub, auth, audit, routes, beforeApproval: (t, i) => control.beforeApproval(t, i), info: async () => ({ control: await control.caps().catch(() => null) }), getPublicUrl: () => publicUrl, getApp: () => flags.app || cfg.app });
 
   server.on('error', (e) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nio-cat",
-  "version": "0.9.6",
+  "version": "0.9.9",
   "description": "nio: fes servir Claude Code, Codex, Grok, Antigravity i Ollama del teu ordinador des del mòbil.",
   "license": "UNLICENSED",
   "author": "f.cat",

package/src/agents/claude.js

@@ -17,6 +17,8 @@ module.exports = {
     const { session, prompt, cfg } = ctx;
     const args = ['-p', prompt, '--output-format', 'stream-json', '--verbose', '--include-partial-messages'];
     if (session.nativeId) args.push('--resume', session.nativeId);
+    // Conversa del terminal: el primer missatge en fa una branca; després ja continua la pròpia.
+    if (session.nativeId && session.forkNative) { args.push('--fork-session'); delete session.forkNative; }
     if (session.model) args.push('--model', session.model);
 
     if (session.mode === 'tot' && process.getuid?.() === 0) {
@@ -110,7 +112,10 @@ function handle(ctx, line) {
         error: ev.is_error ? ev.result || ev.subtype : null,
       });
       break;
+    case 'rate_limit_event':
+      ctx.limits?.(ev.rate_limit_info);
+      break;
     default:
-      break; // rate_limit_event, etc.
+      break;
   }
 }

package/src/agents/ollama.js

@@ -70,11 +70,12 @@ async function pull(name, onProgress, signal) {
 }
 
 // Una resposta d'un sol cop (sense flux), per exemple per a la pissarra.
-async function chat({ model, messages, format }) {
+async function chat({ model, messages, format, think, maxTokens, signal }) {
   const res = await fetch(`${base()}/api/chat`, {
     method: 'POST',
     headers: { 'content-type': 'application/json' },
-    body: JSON.stringify({ model, messages, stream: false, ...(format ? { format } : {}), options: { temperature: 0.2 } }),
+    body: JSON.stringify({ model, messages, stream: false, ...(format ? { format } : {}), ...(think === false ? { think: false } : {}), options: { temperature: 0.2, ...(maxTokens ? { num_predict: maxTokens } : {}) } }),
+    ...(signal ? { signal } : {}),
   });
   if (!res.ok) throw new Error(`Ollama ha tornat un error ${res.status}: ${await res.text()}`);
   const data = await res.json();

package/src/call.js

@@ -0,0 +1,246 @@
+'use strict';
+// Trucada amb en Nio: una conversa de veu en temps real amb un agent d'ElevenLabs (Agents Platform).
+// · La clau d'ElevenLabs es queda en aquest ordinador: el mòbil només rep un URL signat que caduca.
+// · L'agent es crea sol al compte de l'usuari la primera vegada (i es refà si en canviem la definició).
+// · A cada trucada li passem l'estat d'aquest ordinador (agents, sessions, aprovacions) i unes eines
+//   que el navegador reenvia aquí: llegir una sessió, encarregar feina, enviar un missatge o aprovar.
+const os = require('os');
+const path = require('path');
+const config = require('./config');
+const { describe } = require('./hub');
+
+const API = 'https://api.elevenlabs.io/v1/convai';
+const AGENT_V = 1; // puja'l quan canviïn les eines o la configuració de l'agent
+const httpErr = (status, message) => Object.assign(new Error(message), { status });
+const clip = (s, n) => { s = String(s || '').replace(/\s+/g, ' ').trim(); return s.length > n ? `${s.slice(0, n - 1)}…` : s; };
+// «Café» → «cafe»: per trobar carpetes i sessions dites de paraula.
+const norm = (s) => String(s || '').normalize('NFD').replace(/[\u0300-\u036f]/g, '').toLowerCase().replace(/[^a-z0-9]+/g, ' ').trim();
+const ago = (t) => {
+  const m = Math.round((Date.now() - t) / 60000);
+  if (m < 1) return 'ara mateix';
+  if (m < 60) return `fa ${m} minut${m > 1 ? 's' : ''}`;
+  const h = Math.round(m / 60);
+  return h < 24 ? `fa ${h} hor${h > 1 ? 'es' : 'a'}` : `fa ${Math.round(h / 24)} dies`;
+};
+
+const TOOLS = [
+  { type: 'client', name: 'estat', description: 'Torna l’estat actual de l’ordinador: agents instal·lats, sessions i com van, aprovacions pendents i carpetes. Fes-la servir quan et preguntin com va tot o abans de respondre sobre una cosa que pot haver canviat.', expects_response: true, parameters: { type: 'object', properties: {} } },
+  { type: 'client', name: 'llegeix_sessio', description: 'Llegeix els últims missatges d’una sessió per explicar què ha fet o què diu l’agent.', expects_response: true, parameters: { type: 'object', properties: { sessio: { type: 'string', description: 'Títol, carpeta o agent de la sessió, tal com l’ha dit la persona.' } }, required: ['sessio'] } },
+  { type: 'client', name: 'nova_sessio', description: 'Encarrega una feina nova a un agent en una carpeta. Abans de cridar-la, repeteix agent, carpeta i tasca i espera que la persona digui que sí.', expects_response: true, parameters: { type: 'object', properties: { agent: { type: 'string', description: 'Agent: claude, codex, grok, antigravity o ollama.' }, carpeta: { type: 'string', description: 'Nom de la carpeta del projecte.' }, tasca: { type: 'string', description: 'La instrucció completa per a l’agent, ben redactada.' } }, required: ['agent', 'carpeta', 'tasca'] } },
+  { type: 'client', name: 'envia_missatge', description: 'Envia un missatge a una sessió que ja existeix (per continuar la feina). Confirma el text abans d’enviar-lo.', expects_response: true, parameters: { type: 'object', properties: { sessio: { type: 'string', description: 'Títol, carpeta o agent de la sessió.' }, text: { type: 'string', description: 'El missatge per a l’agent.' } }, required: ['sessio', 'text'] } },
+  { type: 'client', name: 'decideix_aprovacio', description: 'Aprova o rebutja una acció que un agent espera. Explica abans què vol fer l’agent i demana confirmació explícita.', expects_response: true, parameters: { type: 'object', properties: { decisio: { type: 'string', enum: ['aprova', 'rebutja'], description: 'aprova o rebutja' }, quina: { type: 'string', description: 'Si n’hi ha més d’una: l’agent, la carpeta o l’acció.' } }, required: ['decisio'] } },
+  { type: 'client', name: 'penja', description: 'Acaba la trucada quan la persona s’acomiada o diu que ja està.', expects_response: false, parameters: { type: 'object', properties: {} } },
+];
+
+const PROMPT = (ctx) => `Ets en Nio, l’assistent de veu de nio. Parles per telèfon amb la persona que fa servir nio: des del mòbil controla els agents d’IA del seu ordinador (Claude Code, Codex…).
+
+Com parles:
+- Sempre en català col·loquial i proper, amb frases curtes. Una o dues frases per torn, tres com a molt.
+- És una trucada: res de Markdown, llistes, emojis, rutes ni identificadors. Els noms de carpeta, dits com a paraules.
+- Si hi ha moltes coses, diu les dues o tres més importants i pregunta si en vol més.
+- No t’inventis res: si no ho saps, fes servir les eines.
+
+Què pots fer:
+- Explicar quins agents té, com van les sessions i què espera aprovació (eina «estat» per tenir-ho al dia, «llegeix_sessio» per als detalls).
+- Encarregar feina nova («nova_sessio»), continuar una sessió («envia_missatge») i aprovar o rebutjar accions («decideix_aprovacio»). Abans de fer qualsevol d’aquestes tres, repeteix en una frase què faràs i espera un sí clar.
+- Quan s’acomiadi, acomiada’t breument i fes servir «penja».
+
+Mentre dura la trucada et poden arribar avisos de context (una sessió acaba, un agent demana permís): explica’ls breument quan sigui oportú.
+
+Estat de l’ordinador ara mateix:
+${ctx}`;
+
+class Call {
+  constructor({ cfg, hub, audit, projects, hookUrl, terminal }) {
+    Object.assign(this, { cfg, hub, audit: audit || { add() {} }, projects, hookUrl, terminal });
+  }
+
+  key() { return this.cfg.voice?.keys?.elevenlabs || ''; }
+  status() { return { ready: !!this.key(), provider: 'elevenlabs', agent: !!this.cfg.voice?.call?.agentId }; }
+
+  async el(method, p, body) {
+    const r = await fetch(`${API}${p}`, { method, headers: { 'xi-api-key': this.key(), ...(body ? { 'content-type': 'application/json' } : {}) }, body: body ? JSON.stringify(body) : undefined, signal: AbortSignal.timeout(20000) });
+    const t = await r.text();
+    let j = null; try { j = JSON.parse(t); } catch { /* text */ }
+    if (!r.ok) {
+      const d = j?.detail;
+      const msg = (typeof d === 'string' ? d : d?.message || (Array.isArray(d) ? d.map((x) => x.msg).join('; ') : '') || j?.message || t || `Error ${r.status}`);
+      throw Object.assign(httpErr(r.status === 401 ? 400 : 502, `ElevenLabs: ${clip(msg, 220)}`), { upstream: r.status });
+    }
+    return j;
+  }
+
+  // L'agent viu al compte d'ElevenLabs de l'usuari. Si no hi és (o és d'una versió antiga), se'n fa un de nou.
+  async ensureAgent() {
+    const c = this.cfg.voice.call || {};
+    if (c.agentId && c.v === AGENT_V) return c;
+    if (c.agentId) this.el('DELETE', `/agents/${c.agentId}`).catch(() => {});
+    const overrides = { conversation_config_override: { agent: { prompt: { prompt: true }, first_message: true, language: true }, tts: { voice_id: true } } };
+    const make = (lang, model, tools) => ({
+      name: `nio · ${os.hostname()}`,
+      conversation_config: {
+        agent: { first_message: 'Hola!', language: lang, prompt: { prompt: 'Ets en Nio, l’assistent de veu de nio.', ...(tools ? { tools: TOOLS } : {}) } },
+        ...(model ? { tts: { model_id: model } } : {}),
+        conversation: { max_duration_seconds: 1200 },
+      },
+      platform_settings: { overrides },
+    });
+    // De més a menys exigent: si el compte o l'API no accepten alguna part, es prova sense.
+    const tries = [['ca', 'eleven_flash_v2_5', true], ['ca', null, true], ['es', 'eleven_flash_v2_5', true], ['ca', null, false], ['en', null, false]];
+    let last;
+    for (const [lang, model, tools] of tries) {
+      try {
+        const r = await this.el('POST', '/agents/create', make(lang, model, tools));
+        this.cfg.voice.call = { agentId: r.agent_id, v: AGENT_V, lang, tools };
+        config.save(this.cfg);
+        this.audit.add({ type: 'call', what: `Agent de veu creat a ElevenLabs (${lang}${tools ? '' : ', sense eines'})` });
+        return this.cfg.voice.call;
+      } catch (e) {
+        last = e;
+        if (e.upstream === 401 || e.upstream === 403) break; // clau dolenta o sense permís: no cal insistir
+      }
+    }
+    throw last.upstream === 401 ? httpErr(400, 'La clau d’ElevenLabs no és vàlida. Canvia-la a Ajustos → Veu.') : last;
+  }
+
+  // ---------------------------------------------------------------- què li expliquem
+  async snapshot() {
+    const { detectAll } = require('./agents');
+    const agents = (await detectAll(this.cfg).catch(() => [])).filter((a) => a.available && a.id !== 'demo');
+    const sessions = this.hub.list();
+    const approvals = this.hub.pendingApprovals();
+    let projects = [];
+    try { projects = this.projects().filter((p) => !p.root).map((p) => p.name); } catch { /* sense carpetes */ }
+    let term = [];
+    try { term = await this.terminal?.(); } catch { /* sense terminal */ }
+    return { agents, sessions, approvals, projects, term: term || [] };
+  }
+  stateLabel(s) {
+    if (s.pending || s.state === 'waiting') return 'espera el teu permís';
+    if (s.state === 'running') return 'treballant';
+    if (s.state === 'error') return `ha fallat${s.error ? ` (${clip(s.error, 80)})` : ''}`;
+    return `acabada ${ago(s.updated)}`;
+  }
+  agentName(id) { return require('./agents').byId?.[id]?.name || { claude: 'Claude Code', codex: 'Codex' }[id] || id; }
+  contextText(snap) {
+    const L = [];
+    L.push(`Ordinador: ${os.hostname()}.`);
+    L.push(snap.agents.length ? `Agents instal·lats: ${snap.agents.map((a) => a.name).join(', ')}.` : 'No hi ha cap agent instal·lat.');
+    const recent = snap.sessions.filter((s) => Date.now() - s.updated < 3 * 864e5 || s.state === 'running' || s.pending).slice(0, 10);
+    const running = snap.sessions.filter((s) => s.state === 'running').length;
+    L.push(`Sessions: ${snap.sessions.length} en total, ${running} treballant ara.`);
+    for (const s of recent) L.push(`- «${clip(s.title || 'sense títol', 70)}», ${this.agentName(s.agent)} a la carpeta ${path.basename(s.cwd)}: ${this.stateLabel(s)}.${s.last ? ` Últim: ${clip(s.last, 140)}` : ''}`);
+    if (snap.approvals.length) {
+      L.push(`Aprovacions pendents: ${snap.approvals.length}.`);
+      for (const a of snap.approvals.slice(0, 5)) L.push(`- ${a.agent ? this.agentName(a.agent) : 'Un agent'}${a.title ? ` («${clip(a.title, 50)}»)` : ''} vol ${clip(`${a.tool}: ${describe(a.tool, a.input)}`, 160)}.`);
+    } else L.push('Cap aprovació pendent.');
+    if (snap.term.length) L.push(`Al terminal hi ha ${snap.term.length} Claude Code obert${snap.term.length > 1 ? 's' : ''}: ${snap.term.slice(0, 4).map((t) => `«${clip(t.title || t.name || path.basename(t.cwd), 50)}» (${t.status === 'busy' ? 'treballant' : 'esperant'})`).join(', ')}.`);
+    if (snap.projects.length) L.push(`Carpetes de projectes: ${snap.projects.slice(0, 40).join(', ')}.`);
+    return L.join('\n');
+  }
+  greeting(snap) {
+    const n = snap.agents.map((a) => a.name);
+    const list = n.length > 1 ? `${n.slice(0, -1).join(', ')} i ${n[n.length - 1]}` : n[0];
+    const running = snap.sessions.filter((s) => s.state === 'running').length, ap = snap.approvals.length;
+    let s = `Hola! Sóc en Nio, et parlo des de l’ordinador ${os.hostname()}. ${n.length ? `Tens ${list}.` : 'Encara no tens cap agent instal·lat.'}`;
+    if (ap) s += ` ${ap === 1 ? 'Hi ha una acció' : `Hi ha ${ap} accions`} esperant el teu permís.`;
+    else if (running) s += ` ${running === 1 ? 'Una sessió està treballant' : `${running} sessions estan treballant`} ara mateix.`;
+    return `${s} Què vols fer?`;
+  }
+
+  async start() {
+    if (!this.key()) throw httpErr(400, 'Per trucar cal una clau d’ElevenLabs. Posa-la a Ajustos → Veu.');
+    this.cfg.voice = this.cfg.voice || {};
+    let a = await this.ensureAgent();
+    const url = async () => (await this.el('GET', `/conversation/get-signed-url?agent_id=${encodeURIComponent(a.agentId)}`)).signed_url;
+    let signed;
+    try { signed = await url(); } catch (e) {
+      if (e.upstream !== 404) throw e;
+      delete this.cfg.voice.call; a = await this.ensureAgent(); signed = await url(); // l'han esborrat al seu tauler
+    }
+    const snap = await this.snapshot();
+    const voiceId = this.cfg.voice.voice?.elevenlabs?.voice;
+    const agentOv = { prompt: { prompt: PROMPT(this.contextText(snap)) }, first_message: this.greeting(snap) };
+    if (a.lang === 'ca') agentOv.language = 'ca';
+    this.audit.add({ type: 'call', what: 'Trucada amb en Nio' });
+    return {
+      signedUrl: signed,
+      tools: !!a.tools,
+      host: os.hostname(),
+      init: { type: 'conversation_initiation_client_data', conversation_config_override: { agent: agentOv, ...(voiceId ? { tts: { voice_id: voiceId } } : {}) } },
+    };
+  }
+
+  // ---------------------------------------------------------------- eines (les crida el navegador)
+  findSession(q) {
+    const list = this.hub.list(), w = norm(q);
+    if (!list.length) return null;
+    if (!w) return list[0];
+    const score = (s) => {
+      const hay = `${norm(s.title)} ${norm(path.basename(s.cwd))} ${norm(this.agentName(s.agent))} ${norm(s.agent)}`;
+      return w.split(' ').filter((t) => t.length > 1 && hay.includes(t)).length * 10 + (s.state === 'running' || s.pending ? 2 : 0);
+    };
+    const best = list.map((s) => [score(s), s]).sort((a, b) => b[0] - a[0] || b[1].updated - a[1].updated)[0];
+    return best[0] > 0 ? best[1] : null;
+  }
+  findFolder(q) {
+    const list = this.projects(), w = norm(q);
+    const exact = list.find((p) => norm(p.name) === w);
+    if (exact) return exact.path;
+    const part = list.filter((p) => !p.root && (norm(p.name).includes(w) || w.includes(norm(p.name)))).sort((a, b) => a.name.length - b.name.length)[0];
+    return part?.path || null;
+  }
+  async tool(name, p = {}) {
+    if (name === 'estat') return this.contextText(await this.snapshot());
+    if (name === 'llegeix_sessio') {
+      const s = this.findSession(p.sessio);
+      if (!s) return 'No he trobat cap sessió amb aquest nom.';
+      const full = this.hub.get(s.id);
+      const msgs = full.events.filter((e) => e.kind === 'user' || e.kind === 'text' || e.kind === 'error').slice(-6)
+        .map((e) => `${e.kind === 'user' ? 'Persona' : e.kind === 'error' ? 'Error' : this.agentName(s.agent)}: ${clip(e.text, 500)}`);
+      return `Sessió «${s.title || 'sense títol'}», ${this.agentName(s.agent)} a ${path.basename(s.cwd)}, ${this.stateLabel(s)}.\n${msgs.join('\n') || 'Encara no hi ha missatges.'}`;
+    }
+    if (name === 'nova_sessio') {
+      const { detectAll } = require('./agents');
+      const avail = (await detectAll(this.cfg)).filter((a) => a.available && a.id !== 'demo');
+      const wa = norm(p.agent);
+      const agent = avail.find((a) => a.id === wa || norm(a.name).includes(wa) || wa.includes(a.id)) || (wa ? null : avail[0]);
+      if (!agent) return `No tinc l’agent «${p.agent}». Hi ha: ${avail.map((a) => a.name).join(', ')}.`;
+      const cwd = this.findFolder(p.carpeta);
+      if (!cwd) return `No trobo la carpeta «${p.carpeta}». Pregunta-li quina és de les que hi ha.`;
+      const task = String(p.tasca || '').trim();
+      if (!task) return 'Falta la tasca.';
+      const s = this.hub.create({ agent: agent.id, cwd, mode: 'preguntar' });
+      this.hub.send(s.id, task, this.hookUrl());
+      this.audit.add({ type: 'call', what: `Feina encarregada per veu a ${agent.name} (${path.basename(cwd)})` });
+      return `Fet: ${agent.name} ja treballa a ${path.basename(cwd)}, amb permisos de «demana permís».`;
+    }
+    if (name === 'envia_missatge') {
+      const s = this.findSession(p.sessio);
+      if (!s) return 'No he trobat aquesta sessió.';
+      try { this.hub.send(s.id, String(p.text || ''), this.hookUrl()); } catch (e) { return `No s’ha pogut enviar: ${e.message}`; }
+      return `Enviat a «${s.title || path.basename(s.cwd)}». ${this.agentName(s.agent)} s’hi posa.`;
+    }
+    if (name === 'decideix_aprovacio') {
+      const list = this.hub.pendingApprovals();
+      if (!list.length) return 'No hi ha cap aprovació pendent.';
+      const w = norm(p.quina);
+      const a = list.length === 1 || !w ? list[0] : list.find((x) => `${norm(x.title)} ${norm(x.agent)} ${norm(x.tool)} ${norm(describe(x.tool, x.input))}`.includes(w)) || null;
+      if (!a) return 'N’hi ha més d’una: pregunta quina.';
+      const allow = p.decisio === 'aprova';
+      this.hub.decide(a.id, allow ? 'allow' : 'deny', allow ? '' : 'Rebutjat per veu', 'Trucada');
+      return allow ? `Aprovat: ${clip(describe(a.tool, a.input), 100)}.` : 'Rebutjat.';
+    }
+    return `No conec l’eina «${name}».`;
+  }
+
+  routes() {
+    return [
+      { method: 'GET', path: '/api/call', handler: () => this.status() },
+      { method: 'POST', path: '/api/call/start', handler: () => this.start() },
+      { method: 'POST', path: '/api/call/tool', handler: async ({ body }) => ({ result: await this.tool(String(body?.name || ''), body?.parameters || {}) }) },
+    ];
+  }
+}
+
+module.exports = { Call, TOOLS, norm, AGENT_V };

package/src/hub.js

@@ -7,6 +7,7 @@ const { EventEmitter } = require('events');
 const { byId, binPath } = require('./agents');
 const { HOME, save } = require('./config');
 const push = require('./push');
+const usage = require('./usage');
 
 const MAX_EVENTS = 3000;
 const MAX_OUT = 4000;
@@ -75,6 +76,8 @@ class Hub extends EventEmitter {
       last: lastText ? clip(lastText.text, 160) : '',
       error: s.state === 'error' ? clip([...s.events].reverse().find((e) => e.kind === 'error')?.text || '', 200) : '',
       pending: [...this.approvals.values()].filter((a) => a.session === s.id && a.state === 'pending').length,
+      nativeId: s.nativeId || null,
+      fromTerminal: s.fromTerminal || null,
     };
   }
 
@@ -160,6 +163,25 @@ class Hub extends EventEmitter {
     return s;
   }
 
+  // Continua una conversa de Claude Code oberta al terminal: n'importa els últims missatges i,
+  // la primera vegada en fa una branca (--fork-session) perquè el terminal i el mòbil no escriguin al mateix fitxer.
+  resumeTerminal(s, nativeId) {
+    const term = require('./terminal');
+    s.nativeId = nativeId; s.fromTerminal = nativeId;
+    const file = term.findTranscript(nativeId, s.cwd);
+    if (file) {
+      const { title, msgs } = term.readTranscript(file);
+      if (title && !s.title) s.title = title;
+      const keep = msgs.slice(-40);
+      if (msgs.length > keep.length) this.push(s, 'info', { text: `${msgs.length - keep.length} missatges anteriors al terminal` });
+      for (const m of keep) this.push(s, m.role === 'user' ? 'user' : 'text', { text: m.text.length > 20000 ? `${m.text.slice(0, 20000)}…` : m.text, t: m.t || Date.now() });
+    }
+    s.forkNative = true;
+    this.push(s, 'info', { text: file ? 'Continua la conversa del terminal. El terminal no es toca: el que facis aquí va per una branca pròpia.' : 'Continua la conversa del terminal.' });
+    this.persist(s);
+    return s;
+  }
+
   remove(sid) {
     this.stop(sid);
     this.sessions.delete(sid);
@@ -269,6 +291,7 @@ class Hub extends EventEmitter {
       },
       toolResult: ({ id: tid, output, error }) =>
         this.push(s, 'tool_result', { id: tid, name: toolNames.get(tid), output: clip(output), error: !!error }),
+      limits: (info) => { if (usage.setClaude(info)) this.emit('out', { type: 'usage', usage: usage.all() }); },
       result: (r) => {
         if (typeof r.cost === 'number') s.cost = (s.cost || 0) + r.cost;
         this.push(s, 'result', r);