nio-cat 0.9.6 → 0.9.7

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

@@ -14,6 +14,7 @@ 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 mcp = require('../src/mcp');
 const directory = require('../src/directory');
 const voice = require('../src/voice');
@@ -213,7 +214,8 @@ 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 routes = [...memory.routes(), ...notes.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.7",
   "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

@@ -110,7 +110,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/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;
@@ -269,6 +270,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);

package/src/notes.js

@@ -0,0 +1,293 @@
+'use strict';
+// Notes: com Google Keep, però a l'ordinador. Es desen a ~/.nio/notes/notes.json i l'àudio a ~/.nio/notes/audio.
+// · Transcripció: el mòbil (o el navegador) grava i l'ordinador transcriu amb Whisper (gratis i local).
+// · Resums i ordre: amb un model local d'Ollama, o amb Claude Code o Codex d'aquest ordinador.
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const crypto = require('crypto');
+const { spawn } = require('child_process');
+const { HOME } = require('./config');
+const { childEnv } = require('./proc');
+const voice = require('./voice');
+const ollama = require('./agents/ollama');
+
+const DIR = path.join(HOME, 'notes');
+const FILE = path.join(DIR, 'notes.json');
+const AUDIO = path.join(DIR, 'audio');
+const MAX_AUDIO = 25 * 1024 * 1024;
+const TRASH_DAYS = 30;
+const COLORS = ['', 'lemon', 'peach', 'moss', 'sky', 'lilac', 'rose', 'sand'];
+const rid = () => crypto.randomBytes(6).toString('base64url');
+const httpErr = (status, message) => Object.assign(new Error(message), { status });
+const extOf = (mime) => (/ogg/.test(mime) ? 'ogg' : /mp4|m4a|aac/.test(mime) ? 'm4a' : /mpeg|mp3/.test(mime) ? 'mp3' : /wav/.test(mime) ? 'wav' : 'webm');
+// «751.63M» → 0,75 · «8.2B» → 8,2 (mil milions de paràmetres)
+const billions = (p) => { const m = String(p || '').match(/([\d.]+)\s*([MB])/i); return m ? parseFloat(m[1]) / (m[2].toUpperCase() === 'M' ? 1000 : 1) : 0; };
+const str = (v, max) => String(v ?? '').slice(0, max);
+
+// Només es deixen passar els camps coneguts, amb límits.
+function clean(b = {}) {
+  const o = {};
+  if ('title' in b) o.title = str(b.title, 200);
+  if ('text' in b) o.text = str(b.text, 200000);
+  if ('items' in b) {
+    o.items = b.items === null ? null : (Array.isArray(b.items) ? b.items : []).slice(0, 500).map((i) => ({ id: str(i?.id, 20) || rid(), text: str(i?.text, 500), done: !!i?.done }));
+  }
+  if ('color' in b) o.color = COLORS.includes(b.color) ? b.color : '';
+  for (const k of ['pinned', 'archived']) if (k in b) o[k] = !!b[k];
+  if ('labels' in b) o.labels = [...new Set((Array.isArray(b.labels) ? b.labels : []).map((l) => str(l, 30).trim()).filter(Boolean))].slice(0, 12);
+  if ('trashed' in b) o.trashed = b.trashed ? Date.now() : 0;
+  return o;
+}
+
+class Notes {
+  constructor({ cfg, hub }) {
+    this.cfg = cfg;
+    this.hub = hub;
+    this.notes = [];
+    this.timer = null;
+    try { this.notes = JSON.parse(fs.readFileSync(FILE, 'utf8')); } catch { /* encara no n'hi ha */ }
+    const old = Date.now() - TRASH_DAYS * 864e5;
+    this.notes = this.notes.filter((n) => !n.trashed || n.trashed > old);
+  }
+
+  save() {
+    clearTimeout(this.timer);
+    this.timer = setTimeout(() => {
+      fs.mkdirSync(DIR, { recursive: true, mode: 0o700 });
+      const tmp = `${FILE}.tmp`;
+      fs.writeFile(tmp, JSON.stringify(this.notes), (e) => { if (!e) fs.rename(tmp, FILE, () => {}); });
+    }, 250);
+    this.timer.unref?.();
+  }
+
+  emit(note) { this.hub.emit('out', { type: 'note', note }); }
+  get(id) { const n = this.notes.find((x) => x.id === id); if (!n) throw httpErr(404, 'Aquesta nota no existeix'); return n; }
+
+  create(body) {
+    const now = Date.now();
+    const n = { id: rid(), title: '', text: '', items: null, color: '', pinned: false, archived: false, trashed: 0, labels: [], audio: [], created: now, updated: now, ...clean(body) };
+    this.notes.unshift(n);
+    this.save();
+    this.emit(n);
+    return n;
+  }
+
+  patch(id, body) {
+    const n = this.get(id);
+    Object.assign(n, clean(body), { updated: Date.now() });
+    this.save();
+    this.emit(n);
+    return n;
+  }
+
+  remove(id, forever) {
+    const n = this.get(id);
+    if (!n.trashed && !forever) return this.patch(id, { trashed: true });
+    for (const a of n.audio) fs.rm(this.audioFile(n, a), { force: true }, () => {});
+    this.notes = this.notes.filter((x) => x !== n);
+    this.save();
+    this.hub.emit('out', { type: 'note-gone', id });
+    return { ok: true };
+  }
+
+  audioFile(n, a) { return path.join(AUDIO, `${n.id}-${a.id}.${extOf(a.mime)}`); }
+
+  // Desa l'àudio i el transcriu en segon pla; el resultat arriba per «note» (flux d'esdeveniments).
+  addAudio(id, buf, mime, dur) {
+    const n = this.get(id);
+    if (!buf?.length || buf.length < 1500) throw httpErr(400, 'No he sentit res. Prova-ho una altra vegada.');
+    const a = { id: rid(), mime, size: buf.length, dur: Number(dur) > 0 ? Math.round(Number(dur)) : 0, at: Date.now(), state: 'transcribing', text: '', error: '' };
+    fs.mkdirSync(AUDIO, { recursive: true, mode: 0o700 });
+    fs.writeFileSync(this.audioFile(n, a), buf);
+    n.audio.push(a);
+    n.updated = Date.now();
+    this.save();
+    this.emit(n);
+    this.transcribe(n, a, buf);
+    return n;
+  }
+
+  retry(id, aid) {
+    const n = this.get(id), a = n.audio.find((x) => x.id === aid);
+    if (!a) throw httpErr(404, 'Aquest àudio no existeix');
+    if (a.state === 'transcribing') return n;
+    a.state = 'transcribing'; a.error = '';
+    this.emit(n);
+    this.transcribe(n, a, fs.readFileSync(this.audioFile(n, a)));
+    return n;
+  }
+
+  async transcribe(n, a, buf) {
+    try {
+      const { text } = await voice.transcribe(this.cfg, buf, a.mime);
+      const t = String(text || '').trim();
+      if (!t) throw new Error('No he entès res en aquest àudio.');
+      a.text = t; a.state = 'ok'; a.error = '';
+      if (n.items) {
+        const parts = t.split(/(?<=[.!?])\s+/).map((s) => s.trim()).filter(Boolean);
+        n.items.push(...parts.map((s) => ({ id: rid(), text: s.slice(0, 500), done: false })));
+      } else {
+        n.text = n.text ? `${n.text.trimEnd()}\n\n${t}` : t;
+      }
+    } catch (e) {
+      a.state = 'error'; a.error = String(e.message || e).slice(0, 300);
+    }
+    if (this.notes.includes(n)) { n.updated = Date.now(); this.save(); this.emit(n); }
+  }
+
+  // ---------- Motors per resumir i organitzar
+  async engines() {
+    const { binPath } = require('./agents');
+    const out = [];
+    const models = await ollama.listModels();
+    // Un model «:cloud» d'Ollama s'executa als seus servidors: no compta com a local. Els locals, de petit a gran.
+    for (const m of [...(models || [])].sort((a, b) => (/cloud/.test(a.name) || !a.size) - (/cloud/.test(b.name) || !b.size) || a.size - b.size)) {
+      const cloud = /:cloud$|-cloud$/.test(m.name) || !m.size;
+      out.push({ id: `ollama:${m.name}`, label: `${m.name}${m.params ? ` · ${m.params}` : ''}${cloud ? ' · núvol' : ''}`, local: !cloud, group: cloud ? 'Ollama (núvol)' : 'Local (Ollama)', size: m.size, params: billions(m.params) });
+    }
+    if (binPath(this.cfg, 'claude')) out.push({ id: 'claude:haiku', label: 'Claude Code · ràpid', local: false, group: 'Claude Code' }, { id: 'claude', label: 'Claude Code · model per defecte', local: false, group: 'Claude Code' });
+    if (binPath(this.cfg, 'codex')) out.push({ id: 'codex', label: 'Codex', local: false, group: 'Codex' });
+    return out;
+  }
+
+  async ai({ id, action, engine, prompt }) {
+    const n = this.get(id);
+    const body = n.items ? `${n.text ? `${n.text}\n\n` : ''}${n.items.map((i) => `- [${i.done ? 'x' : ' '}] ${i.text}`).join('\n')}` : n.text;
+    if (!`${n.title}${body}`.trim()) throw httpErr(400, 'La nota és buida');
+    const spec = ACTIONS[action];
+    if (!spec) throw httpErr(400, 'Acció desconeguda');
+    if (action === 'custom' && !String(prompt || '').trim()) throw httpErr(400, 'Escriu què vols que faci');
+    const list = await this.engines();
+    // Per defecte: el model local més petit de 3 mil milions de paràmetres o més; si no, Claude ràpid; si no, el primer.
+    const auto = list.filter((e) => e.local && e.id.startsWith('ollama:') && e.params >= 3)[0] || list.find((e) => e.id === 'claude:haiku') || list[0];
+    const pick = list.find((e) => e.id === engine) || auto;
+    if (!pick) throw httpErr(400, 'No hi ha cap model en aquest ordinador. Instal·la Ollama amb un model (ollama pull qwen3:4b) o Claude Code.');
+    // La nota va primer i la instrucció al final: els models petits segueixen millor l'última cosa que llegeixen.
+    const user = `--- NOTA ---\nTítol: ${n.title || '(sense títol)'}\n\n${body.slice(0, 40000)}\n--- FI DE LA NOTA ---\n\n${spec.task(String(prompt || '').slice(0, 1000))}`;
+    // Els models locals petits «pensen» en veu alta quan responen en text lliure (minuts). En mode JSON surten directes.
+    const local = pick.id.startsWith('ollama:'), wrap = !spec.json && local;
+    const raw = await runModel(this.cfg, pick.id, SYSTEM, wrap ? `${user}\n\nTorna només JSON amb aquest format: {"text":"…"}. El text pot tenir salts de línia.` : user, spec.json || wrap);
+    const result = spec.json ? parseJson(raw) : wrap ? { text: String(parseJson(raw).text ?? '').trim() } : { text: raw.trim() };
+    if (typeof result.text === 'string' && /--- (FI DE LA )?NOTA ---|Torna només JSON/.test(result.text)) throw httpErr(502, 'El model ha respost malament. Torna-ho a provar o tria un model més gran.');
+    if (typeof result.text === 'string') result.text = result.text.replace(/^\s*T[ií]tol:[^\n]*\n+/i, '').trim(); // els models petits repeteixen el títol
+    return { engine: pick.id, local: pick.local, action, result: spec.shape(result, n) };
+  }
+
+  routes() {
+    const R = (method, path, handler, extra = {}) => ({ method, path, handler, ...extra });
+    return [
+      R('GET', '/api/notes', () => ({ notes: this.notes })),
+      R('POST', '/api/notes', ({ body }) => this.create(body), { limit: 1024 * 1024 }),
+      R('GET', '/api/notes/engines', () => this.engines().then((engines) => ({ engines }))),
+      R('POST', '/api/notes/ai', ({ body }) => this.ai(body || {})),
+      R('PATCH', /^\/api\/notes\/([\w-]+)$/, ({ params, body }) => this.patch(params[0], body), { limit: 1024 * 1024 }),
+      R('DELETE', /^\/api\/notes\/([\w-]+)$/, ({ params, url }) => this.remove(params[0], url.searchParams.get('forever') === '1')),
+      R('POST', /^\/api\/notes\/([\w-]+)\/audio$/, async ({ req, params, url }) => this.addAudio(params[0], await readRaw(req), String(req.headers['content-type'] || 'audio/webm').split(';')[0], url.searchParams.get('dur')), { raw: true }),
+      R('POST', /^\/api\/notes\/([\w-]+)\/audio\/([\w-]+)\/retry$/, ({ params }) => this.retry(params[0], params[1])),
+      R('GET', /^\/api\/notes\/([\w-]+)\/audio\/([\w-]+)$/, ({ res, params }) => {
+        const n = this.get(params[0]), a = n.audio.find((x) => x.id === params[1]);
+        if (!a) throw httpErr(404, 'Aquest àudio no existeix');
+        const buf = fs.readFileSync(this.audioFile(n, a));
+        res.writeHead(200, { 'content-type': a.mime, 'content-length': buf.length, 'cache-control': 'no-store' });
+        res.end(buf);
+      }),
+    ];
+  }
+}
+
+function readRaw(req, limit = MAX_AUDIO) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let size = 0;
+    req.on('data', (c) => { size += c.length; if (size > limit) { reject(httpErr(413, 'L’àudio és massa llarg')); req.destroy(); } else chunks.push(c); });
+    req.on('end', () => resolve(Buffer.concat(chunks)));
+    req.on('error', reject);
+  });
+}
+
+// ---------- Instruccions per a cada acció
+const SYSTEM = 'Ets l’assistent de notes de nio. Treballes només amb el text de la nota que et donen. No hi afegeixes res que no hi sigui. Respon en l’idioma de la nota (si dubtes, en català). No facis servir cap eina.';
+const ACTIONS = {
+  summary: {
+    json: false,
+    task: () => 'Escriu un resum de 3 a 5 punts curts amb les idees principals de la nota, amb altres paraules (no copiïs el text). Cada punt comença amb «- ». Només els punts, sense introducció ni títol.',
+    shape: (r) => ({ text: r.text }),
+  },
+  clean: {
+    json: false,
+    task: () => 'La nota és una transcripció de veu. Posa-hi puntuació i majúscules, divideix-la en paràgrafs i treu els «eh», repeticions i falsos començaments. No canviïs el sentit ni resumeixis. Torna només el text net, sense el títol.',
+    shape: (r) => ({ text: r.text }),
+  },
+  tasks: {
+    json: true,
+    task: () => 'Extreu les tasques pendents de la nota. Torna només JSON amb aquest format: {"items":["tasca 1","tasca 2"]}. Cada tasca és una frase curta i en forma d’acció. Si no n’hi ha cap, {"items":[]}.',
+    shape: (r) => ({ items: (Array.isArray(r.items) ? r.items : []).map((s) => str(s, 300).trim()).filter(Boolean).slice(0, 50) }),
+  },
+  organize: {
+    json: true,
+    task: () => 'Organitza la nota: dona-li un títol curt, ordena el contingut en paràgrafs o llistes amb Markdown senzill i proposa 1 a 3 etiquetes d’una paraula en minúscula. Conserva tot el contingut important. Torna només JSON amb aquest format: {"title":"…","text":"…","labels":["…"]}.',
+    shape: (r, n) => ({ title: str(r.title, 200).trim() || n.title, text: str(r.text, 200000).trim(), labels: (Array.isArray(r.labels) ? r.labels : []).map((l) => str(l, 30).trim().toLowerCase()).filter(Boolean).slice(0, 3) }),
+  },
+  title: {
+    json: true,
+    task: () => 'Proposa un títol de menys de 8 paraules per a la nota. Torna només JSON amb aquest format: {"title":"…"}.',
+    shape: (r) => ({ title: str(r.title, 200).trim() }),
+  },
+  custom: {
+    json: false,
+    task: (p) => `Fes això amb la nota: ${p}\nTorna només el resultat, en text.`,
+    shape: (r) => ({ text: r.text }),
+  },
+};
+
+function parseJson(raw) {
+  const t = String(raw || '').replace(/^```(?:json)?\s*|\s*```$/g, '').trim();
+  try { return JSON.parse(t); } catch { /* potser hi ha text al voltant */ }
+  const i = t.indexOf('{'), j = t.lastIndexOf('}');
+  if (i >= 0 && j > i) { try { return JSON.parse(t.slice(i, j + 1)); } catch { /* res */ } }
+  throw httpErr(502, 'El model no ha tornat una resposta que pugui entendre. Prova-ho amb un altre model.');
+}
+
+// ---------- Execució d'un model, d'un sol cop
+function runCli(bin, args, input, { cwd, timeout = 180000 } = {}) {
+  return new Promise((resolve, reject) => {
+    const p = spawn(bin, args, { cwd, env: childEnv(), stdio: ['pipe', 'pipe', 'pipe'] });
+    let out = '', err = '';
+    const t = setTimeout(() => { p.kill('SIGKILL'); reject(httpErr(504, 'El model ha trigat massa. Prova-ho amb un de més petit o ràpid.')); }, timeout);
+    p.stdout.on('data', (d) => { out += d; });
+    p.stderr.on('data', (d) => { err += d; });
+    p.on('error', (e) => { clearTimeout(t); reject(httpErr(500, `No he pogut engegar ${path.basename(bin)}: ${e.message}`)); });
+    p.on('close', (code) => { clearTimeout(t); code === 0 ? resolve(out) : reject(httpErr(502, (err || out || `Error ${code}`).trim().slice(-300))); });
+    p.stdin.on('error', () => {});
+    p.stdin.end(input);
+  });
+}
+
+async function runModel(cfg, engine, system, user, json) {
+  const { binPath } = require('./agents');
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'nio-nota-'));
+  try {
+    if (engine.startsWith('ollama:')) {
+      // Qwen3 «pensa» abans de respondre (minuts en un model petit): «/no_think» ho desactiva. Si la resposta porta un bloc <think>, es treu.
+      const model = engine.slice(7), soft = /qwen3/i.test(model) ? '\n\n/no_think' : '';
+      const out = await ollama.chat({ model, messages: [{ role: 'system', content: system }, { role: 'user', content: user + soft }], format: json ? 'json' : undefined, think: false, maxTokens: 3000, signal: AbortSignal.timeout(150000) }).catch((e) => { throw e.name === 'TimeoutError' ? httpErr(504, 'El model ha trigat massa. Prova-ho amb un de més petit o ràpid.') : e; });
+      return out.replace(/^[\s\S]*?<\/think>\s*/i, '').trim();
+    }
+    if (engine === 'claude' || engine.startsWith('claude:')) {
+      const args = ['-p', '--tools', '', '--no-session-persistence', '--output-format', 'text', '--system-prompt', system];
+      if (engine.startsWith('claude:')) args.push('--model', engine.slice(7));
+      return await runCli(binPath(cfg, 'claude'), args, user, { cwd: tmp });
+    }
+    if (engine === 'codex') {
+      const outFile = path.join(tmp, 'resposta.txt');
+      await runCli(binPath(cfg, 'codex'), ['exec', '--skip-git-repo-check', '--ephemeral', '-s', 'read-only', '-C', tmp, '-o', outFile, '-'], `${system}\n\n${user}`, { cwd: tmp });
+      return fs.readFileSync(outFile, 'utf8');
+    }
+    throw httpErr(400, 'Motor desconegut');
+  } finally {
+    fs.rm(tmp, { recursive: true, force: true }, () => {});
+  }
+}
+
+module.exports = { Notes, DIR, clean, parseJson, ACTIONS, COLORS };

package/src/server.js

@@ -14,6 +14,7 @@ const { addServer, knownHosts } = require('./ssh');
 const { agentCommands } = require('./commands');
 const { pairLink, qrSvg, makeCode, codeLink } = require('./pair');
 const directory = require('./directory');
+const usage = require('./usage');
 
 // L'app web: copiada dins del paquet en publicar-lo, o l'arrel del repositori en desenvolupament.
 const WEB_DIRS = [path.join(__dirname, '..', 'web'), path.join(__dirname, '..', '..')];
@@ -160,9 +161,24 @@ function createServer({ cfg, hub, auth, audit, getPublicUrl, getApp, routes = []
   const seenDevices = new Map(); // mòbils que s'han connectat (per avisar l'ordinador que mostra el QR)
   const pulls = new Map(); // descàrregues de models d'Ollama en curs
 
-  hub.on('out', (msg) => {
+  // Els trossos de text surten de seguida el primer cop i després s'agrupen cada 40 ms: menys paquets i menys repintats al mòbil.
+  const writeOut = (msg) => {
     const data = `data: ${JSON.stringify(msg)}\n\n`;
     for (const res of streams.keys()) res.write(data);
+  };
+  let pendDelta = null, deltaWin = 0;
+  const flushDelta = () => { if (pendDelta) { const d = pendDelta; pendDelta = null; writeOut(d); } };
+  hub.on('out', (msg) => {
+    if (msg.type === 'delta') {
+      if (pendDelta && (pendDelta.session !== msg.session || pendDelta.seq !== msg.seq)) flushDelta();
+      if (deltaWin) { if (pendDelta) pendDelta.text += msg.text; else pendDelta = { ...msg }; return; }
+      writeOut(msg);
+      deltaWin = setTimeout(() => { deltaWin = 0; flushDelta(); }, 40);
+      deltaWin.unref?.();
+      return;
+    }
+    flushDelta();
+    writeOut(msg);
   });
   setInterval(() => {
     for (const res of streams.keys()) res.write(': ping\n\n');
@@ -181,6 +197,7 @@ function createServer({ cfg, hub, auth, audit, getPublicUrl, getApp, routes = []
       return hit.r.handler({ req, res, url, params: hit.params, body, device });
     }
 
+    if (p === '/api/usage' && method === 'GET') return usage.all();
     if (p === '/api/info' && method === 'GET') {
       return {
         name: 'nio',
@@ -453,7 +470,7 @@ function createServer({ cfg, hub, auth, audit, getPublicUrl, getApp, routes = []
           connection: 'keep-alive',
         });
         req.socket?.setNoDelay(true);
-        res.write(`data: ${JSON.stringify({ type: 'hello', sessions: hub.list(), approvals: hub.pendingApprovals() })}\n\n`);
+        res.write(`data: ${JSON.stringify({ type: 'hello', sessions: hub.list(), approvals: hub.pendingApprovals(), usage: usage.all() })}\n\n`);
         const dev = String(url.searchParams.get('d') || '').slice(0, 40), kind = url.searchParams.get('k') === 'phone' ? 'phone' : 'desktop';
         if (dev && kind === 'phone' && Date.now() - (seenDevices.get(dev) || 0) > 10 * 60 * 1000) {
           const data = `data: ${JSON.stringify({ type: 'device', device: dev, kind })}\n\n`;

package/src/usage.js

@@ -0,0 +1,79 @@
+'use strict';
+// Ús de la subscripció (finestra de 5 h i de la setmana). Claude el diu al flux (rate_limit_event);
+// Codex el desa als seus registres (~/.codex/sessions). No es llegeix cap clau ni cap compte.
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { HOME } = require('./config');
+
+const FILE = path.join(HOME, 'usage.json');
+const CODEX_DIR = path.join(os.homedir(), '.codex', 'sessions');
+const saved = {}; // agent -> { windows: [{ label, used, resetsAt }], at }
+try { Object.assign(saved, JSON.parse(fs.readFileSync(FILE, 'utf8'))); } catch { /* encara res */ }
+
+const LABELS = { five_hour: '5 h', seven_day: 'setmana' };
+const num = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : null);
+const label = (min) => (min === 300 ? '5 h' : min === 10080 ? 'setmana' : min % 60 === 0 ? `${min / 60} h` : `${min} min`);
+
+// Claude: { unifiedWindows: { five_hour: { utilization: 0..1, resetsAt: segons }, seven_day: … } }
+function setClaude(info) {
+  const windows = [];
+  for (const [k, w] of Object.entries(info?.unifiedWindows || {})) {
+    const used = num(w?.utilization);
+    if (used === null || !LABELS[k]) continue;
+    windows.push({ label: LABELS[k], used: Math.min(1, Math.max(0, used)), resetsAt: num(w.resetsAt) });
+  }
+  if (!windows.length) return false;
+  windows.sort((a, b) => (a.label === '5 h' ? -1 : 1) - (b.label === '5 h' ? -1 : 1));
+  const prev = JSON.stringify(saved.claude?.windows);
+  saved.claude = { windows, at: Date.now() };
+  if (JSON.stringify(windows) === prev) return false;
+  fs.writeFile(FILE, JSON.stringify({ claude: saved.claude }), () => {});
+  return true;
+}
+
+// Codex: l'últim `token_count` de l'últim registre porta rate_limits.{primary,secondary}.
+const desc = (dir) => { try { return fs.readdirSync(dir).sort().reverse(); } catch { return []; } };
+function codexFiles(max = 3) {
+  const out = [];
+  for (const y of desc(CODEX_DIR)) for (const m of desc(path.join(CODEX_DIR, y))) for (const d of desc(path.join(CODEX_DIR, y, m))) {
+    for (const f of desc(path.join(CODEX_DIR, y, m, d))) { if (f.endsWith('.jsonl')) out.push(path.join(CODEX_DIR, y, m, d, f)); if (out.length >= max) return out; }
+  }
+  return out;
+}
+function tailLimits(file) {
+  let fd;
+  try {
+    fd = fs.openSync(file, 'r');
+    const size = fs.fstatSync(fd).size, len = Math.min(size, 256 * 1024), buf = Buffer.alloc(len);
+    fs.readSync(fd, buf, 0, len, size - len);
+    const lines = buf.toString('utf8').split('\n');
+    for (let i = lines.length - 1; i >= 0; i--) {
+      if (!lines[i].includes('"rate_limits"')) continue;
+      let o; try { o = JSON.parse(lines[i]); } catch { continue; }
+      const rl = o?.payload?.rate_limits; if (!rl) continue;
+      const windows = ['primary', 'secondary'].map((k) => rl[k]).filter(Boolean).map((w) => ({ label: label(w.window_minutes), used: Math.min(1, Math.max(0, (num(w.used_percent) || 0) / 100)), resetsAt: num(w.resets_at) }));
+      if (windows.length) return { windows, at: Date.parse(o.timestamp) || Date.now() };
+    }
+  } catch { /* sense registre */ } finally { if (fd !== undefined) fs.closeSync(fd); }
+  return null;
+}
+let codexCache = { t: 0, v: null };
+function codex() {
+  if (Date.now() - codexCache.t < 5000) return codexCache.v;
+  let v = null;
+  for (const f of codexFiles()) if ((v = tailLimits(f))) break;
+  codexCache = { t: Date.now(), v };
+  return v;
+}
+
+// Una finestra que ja s'ha reiniciat torna a 0 fins que l'agent n'informi de nou.
+const fresh = (u) => u && { windows: u.windows.map((w) => (w.resetsAt && w.resetsAt * 1000 <= Date.now() ? { label: w.label, used: 0, resetsAt: null } : w)), at: u.at };
+function all() {
+  const out = {}, c = fresh(saved.claude), x = fresh(codex());
+  if (c) out.claude = c;
+  if (x) out.codex = x;
+  return out;
+}
+
+module.exports = { setClaude, all };