nio-cat 0.5.0 → 0.6.1

package/src/hub.js

@@ -19,9 +19,10 @@ const clip = (s, n = MAX_OUT) => {
 };
 
 class Hub extends EventEmitter {
-  constructor(cfg) {
+  constructor(cfg, { audit } = {}) {
     super();
     this.cfg = cfg;
+    this.audit = audit || { add() {} };
     this.sessions = new Map();
     this.runs = new Map(); // sessionId -> { kill, key }
     this.approvals = new Map(); // approvalId -> { ..., resolve }
@@ -163,12 +164,38 @@ class Hub extends EventEmitter {
     this.emit('out', { type: 'removed', session: sid });
   }
 
+  // Codex no té /status en mode headless: ho resolem aquí amb el que sí que sap dir.
+  codexStatus(s, bp) {
+    const { execFile } = require('child_process');
+    execFile(bp, ['login', 'status'], { timeout: 8000 }, (err, out, errOut) => {
+      const rows = String(out || errOut || '').split('\n').map((l) => l.trim()).filter(Boolean), login = rows.find((l) => /logged|log in|login/i.test(l) && !/^warning/i.test(l)) || rows[0] || (err ? 'No he pogut llegir el compte' : '');
+      const lines = [`**Compte:** ${login}`, `**Model:** ${s.model || s.modelUsed || 'el de per defecte'}`, `**Carpeta:** \`${s.cwd}\``, `**Permisos:** ${s.mode}`, `**Conversa:** ${s.nativeId ? 'continua la de Codex' : 'encara no ha començat'}`];
+      this.push(s, 'text', { text: lines.join('\n\n') });
+      this.touch(s);
+    });
+    return this.summary(s);
+  }
+
   update(sid, patch) {
     const s = this.get(sid);
     if (!s) throw httpErr(404, 'Aquesta sessió no existeix');
     if (patch.mode && ['llegir', 'preguntar', 'tot'].includes(patch.mode)) s.mode = patch.mode;
     if (typeof patch.title === 'string') s.title = patch.title.slice(0, 120);
     if (typeof patch.model === 'string') s.model = patch.model.slice(0, 80);
+    if (typeof patch.cwd === 'string' && path.resolve(patch.cwd) !== s.cwd) {
+      const cwd = path.resolve(patch.cwd);
+      if (s.state === 'running' || s.state === 'waiting') throw httpErr(409, 'Espera que l’agent acabi o atura’l abans de canviar de carpeta');
+      let ok = false;
+      try { ok = fs.statSync(cwd).isDirectory(); } catch { /* no existeix */ }
+      if (!ok) throw httpErr(400, 'Aquesta carpeta no existeix');
+      // Claude Code desa cada conversa dins la carpeta del projecte: la copiem perquè l'agent la recordi.
+      if (s.agent === 'claude' && s.nativeId) {
+        const enc = (d) => path.join(require('os').homedir(), '.claude', 'projects', d.replace(/[^a-zA-Z0-9]/g, '-'), `${s.nativeId}.jsonl`);
+        try { fs.mkdirSync(path.dirname(enc(cwd)), { recursive: true }); fs.copyFileSync(enc(s.cwd), enc(cwd)); } catch { s.nativeId = null; }
+      }
+      s.cwd = cwd;
+      this.push(s, 'info', { text: `Carpeta canviada a ${cwd}` });
+    }
     this.touch(s);
     return this.summary(s);
   }
@@ -201,6 +228,7 @@ class Hub extends EventEmitter {
 
     if (!s.title) s.title = text.replace(/\s+/g, ' ').slice(0, 60);
     this.push(s, 'user', { text });
+    if (s.agent === 'codex' && /^\/status\s*$/i.test(text)) return this.codexStatus(s, bp);
     s.state = 'running';
     this.push(s, 'status', { state: 'running' });
 
@@ -231,7 +259,9 @@ class Hub extends EventEmitter {
       stream: (t) => this.chunk(s, String(t)),
       tool: ({ id: tid, name, input }) => {
         toolNames.set(tid, name);
-        this.push(s, 'tool', { id: tid, name, input: summarizeInput(input) });
+        const inp = summarizeInput(input);
+        this.push(s, 'tool', { id: tid, name, input: inp });
+        this.audit.add({ type: 'tool', session: s.id, agent: s.agent, title: s.title, cwd: s.cwd, tool: name, what: describe(name, inp), mode: s.mode });
       },
       toolResult: ({ id: tid, output, error }) =>
         this.push(s, 'tool_result', { id: tid, name: toolNames.get(tid), output: clip(output), error: !!error }),
@@ -260,7 +290,7 @@ class Hub extends EventEmitter {
         finished = true;
         this.runs.delete(sid);
         for (const a of this.approvals.values()) {
-          if (a.session === sid && a.state === 'pending') this.decide(a.id, 'deny', 'La sessió s’ha acabat');
+          if (a.session === sid && a.state === 'pending') this.decide(a.id, 'deny', 'La sessió s’ha acabat', 'sessió acabada');
         }
         if (err) this.push(s, 'error', { text: `No s’ha pogut engegar: ${err.message}` });
         else if (code && code !== 0 && code !== 130 && code !== 143 && !reported) {
@@ -301,7 +331,15 @@ class Hub extends EventEmitter {
     return a.length === b.length && crypto.timingSafeEqual(a, b);
   }
 
-  requestApproval({ session, tool, input }) {
+  // El motiu: la descripció que dona l'agent (p. ex. el camp «description» de Bash a Claude Code)
+  // o, si no n'hi ha, l'últim que ha dit abans de demanar-ho.
+  reasonFor(s, input) {
+    if (input && typeof input.description === 'string' && input.description.trim()) return clip(input.description, 400);
+    const last = s ? [...s.events].reverse().find((e) => e.kind === 'text' || e.kind === 'user') : null;
+    return last && last.kind === 'text' ? clip(last.text.trim(), 400) : '';
+  }
+
+  requestApproval({ session, tool, input, extra }) {
     const s = this.get(session);
     const a = {
       id: id(),
@@ -310,29 +348,38 @@ class Hub extends EventEmitter {
       title: s?.title,
       tool,
       input: summarizeInput(input),
+      reason: this.reasonFor(s, input),
       state: 'pending',
       created: Date.now(),
+      ...(extra || {}),
     };
     const p = new Promise((resolve) => {
       a.resolve = resolve;
-      a.timer = setTimeout(() => this.decide(a.id, 'deny', 'Ningú no ha respost en 15 minuts'), APPROVAL_TIMEOUT);
+      a.timer = setTimeout(() => this.decide(a.id, 'deny', 'Ningú no ha respost en 15 minuts', 'temps esgotat'), APPROVAL_TIMEOUT);
     });
     this.approvals.set(a.id, a);
     if (s) {
       s.state = 'waiting';
-      this.push(s, 'approval', { approval: a.id, tool, input: a.input, state: 'pending' });
+      this.push(s, 'approval', { approval: a.id, tool, input: a.input, reason: a.reason, shot: a.shot, state: 'pending' });
     }
     this.emit('out', { type: 'approval', approval: publicApproval(a) });
-    this.notice(s, `${agentName(s)} et demana permís`, `${tool}: ${describe(tool, a.input)}`);
+    this.notice(s, `${agentName(s)} et demana permís`, `${tool}: ${describe(tool, a.input)}`, { approval: a.id });
     return p;
   }
 
-  decide(aid, decision, reason) {
+  // `by`: qui ho ha decidit (nom del dispositiu, «Telegram · …», «temps esgotat»…).
+  decide(aid, decision, reason, by) {
     const a = this.approvals.get(aid);
     if (!a || a.state !== 'pending') return null;
     clearTimeout(a.timer);
     a.state = decision === 'allow' ? 'allowed' : 'denied';
     a.decided = Date.now();
+    a.by = by || 'nio';
+    this.audit.add({
+      type: 'approval', approval: a.id, session: a.session, agent: a.agent, title: a.title,
+      tool: a.tool, what: describe(a.tool, a.input), why: a.reason, decision: a.state, by: a.by,
+      asked: a.created, note: reason || undefined,
+    });
     const s = this.get(a.session);
     if (s) {
       const ev = s.events.find((e) => e.kind === 'approval' && e.approval === aid);
@@ -354,12 +401,13 @@ class Hub extends EventEmitter {
   }
 
   // ---------- avisos (push) ----------
-  notice(s, title, body) {
-    const n = { id: id(6), t: Date.now(), title, body: clip(body || '', 180), session: s?.id };
+  notice(s, title, body, extra = {}) {
+    const n = { id: id(6), t: Date.now(), title, body: clip(body || '', 180), session: s?.id, node: this.cfg.id, ...extra };
     this.notices.unshift(n);
     this.notices.length = Math.min(this.notices.length, 20);
+    this.emit('notice', n, s);
     if (!this.cfg.pushSubs?.length) return;
-    push.notifyAll(this.cfg).then((dead) => {
+    push.notifyAll(this.cfg, n).then((dead) => {
       if (dead.length) {
         this.cfg.pushSubs = this.cfg.pushSubs.filter((x) => !dead.includes(x.endpoint));
         save(this.cfg);
@@ -407,4 +455,4 @@ function httpErr(status, message) {
   return e;
 }
 
-module.exports = { Hub, httpErr };
+module.exports = { Hub, httpErr, describe };

package/src/jobs.js

@@ -0,0 +1,287 @@
+'use strict';
+// Orquestrador lleuger: cua de feines, cadenes i programació. No fa la feina: obre sessions de
+// Claude Code o Codex (via el hub) i les va seguint. Tot es desa a ~/.nio/jobs.json.
+//
+// Estats: pendent → en curs → feta | fallada (o cancel·lada).
+// · Cadena: `after` = id d'una altra feina. Comença quan aquella acaba bé (o sempre, amb `always`).
+//   El text «{{anterior}}» del missatge es canvia per l'última resposta de la feina anterior.
+// · Programació: `at` (una vegada) o `cron` (periòdica, 5 camps). Una programació periòdica és una
+//   plantilla: cada vegada que toca, crea una feina nova a la cua.
+// · Encaminament: amb agent «auto», la primera regla de cfg.routing que coincideix tria l'agent.
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const { HOME } = require('./config');
+
+const FILE = path.join(HOME, 'jobs.json');
+const ACTIVE = new Set(['pendent', 'en curs']);
+const rid = () => crypto.randomBytes(6).toString('base64url');
+const httpErr = (status, message) => Object.assign(new Error(message), { status });
+
+// ---------- cron (minut hora dia-del-mes mes dia-de-la-setmana)
+function field(spec, min, max) {
+  const out = new Set();
+  for (const part of String(spec).split(',')) {
+    const m = part.match(/^(\*|(\d+)(?:-(\d+))?)(?:\/(\d+))?$/);
+    if (!m) throw httpErr(400, `Programació no vàlida: «${part}»`);
+    let lo = m[1] === '*' ? min : Number(m[2]);
+    let hi = m[1] === '*' ? max : m[3] != null ? Number(m[3]) : m[4] ? max : lo;
+    const step = m[4] ? Number(m[4]) : 1;
+    if (lo < min || hi > max || lo > hi || step < 1) throw httpErr(400, `Programació fora de límits: «${part}»`);
+    for (let v = lo; v <= hi; v += step) out.add(v);
+  }
+  return out;
+}
+function parseCron(expr) {
+  const f = String(expr || '').trim().split(/\s+/);
+  if (f.length !== 5) throw httpErr(400, 'La programació ha de tenir 5 camps: minut hora dia mes dia-de-la-setmana');
+  const dow = field(f[4], 0, 7);
+  if (dow.has(7)) dow.add(0);
+  return { min: field(f[0], 0, 59), hour: field(f[1], 0, 23), dom: field(f[2], 1, 31), mon: field(f[3], 1, 12), dow, domAny: f[2] === '*', dowAny: f[4] === '*' };
+}
+// Pròxima hora (hora local de l'ordinador) estrictament posterior a `from`.
+function nextCron(expr, from = Date.now()) {
+  const c = typeof expr === 'string' ? parseCron(expr) : expr;
+  const d = new Date(from);
+  d.setSeconds(0, 0);
+  d.setMinutes(d.getMinutes() + 1);
+  for (let i = 0; i < 60 * 24 * 366; i++) {
+    const dayOk = c.domAny && c.dowAny ? true : c.domAny ? c.dow.has(d.getDay()) : c.dowAny ? c.dom.has(d.getDate()) : c.dom.has(d.getDate()) || c.dow.has(d.getDay());
+    if (!c.mon.has(d.getMonth() + 1) || !dayOk) { d.setHours(24, 0, 0, 0); continue; }
+    if (!c.hour.has(d.getHours())) { d.setHours(d.getHours() + 1, 0, 0, 0); continue; }
+    if (c.min.has(d.getMinutes())) return d.getTime();
+    d.setMinutes(d.getMinutes() + 1);
+  }
+  return null;
+}
+
+// ---------- encaminament
+function route(cfg, prompt, available) {
+  for (const r of cfg.routing || []) {
+    try {
+      if (r.agent && available.includes(r.agent) && new RegExp(r.match, 'i').test(prompt)) return { agent: r.agent, cwd: r.cwd, rule: r.match };
+    } catch {
+      /* regla mal escrita: la saltem */
+    }
+  }
+  const def = ['claude', 'codex'].find((a) => available.includes(a)) || available[0];
+  return { agent: def, rule: null };
+}
+
+class Jobs {
+  constructor({ cfg, hub, audit, available = () => ['claude', 'codex'], file = FILE }) {
+    this.cfg = cfg;
+    this.hub = hub;
+    this.audit = audit || { add() {} };
+    this.available = available;
+    this.file = file;
+    this.jobs = [];
+    try {
+      this.jobs = JSON.parse(fs.readFileSync(file, 'utf8'));
+    } catch {
+      /* primer cop */
+    }
+    // Si nio s'ha reiniciat amb feines en curs, la sessió ja no corre: les donem per fallades.
+    for (const j of this.jobs) if (j.state === 'en curs') this.finish(j, 'fallada', 'nio s’ha reiniciat mentre treballava', true);
+    hub.on('out', (m) => this.onHub(m));
+  }
+
+  save() {
+    const tmp = `${this.file}.tmp`;
+    fs.writeFileSync(tmp, JSON.stringify(this.jobs.slice(-500), null, 2), { mode: 0o600 });
+    fs.renameSync(tmp, this.file);
+  }
+
+  emit(j) {
+    this.hub.emit('out', { type: 'job', job: j });
+  }
+
+  list() {
+    return [...this.jobs].sort((a, b) => b.created - a.created);
+  }
+
+  get(id) {
+    return this.jobs.find((j) => j.id === id);
+  }
+
+  add(b) {
+    const prompt = String(b.prompt || '').trim();
+    if (!prompt) throw httpErr(400, 'Explica què ha de fer la feina');
+    const avail = this.available();
+    let agent = b.agent || 'auto', cwd = b.cwd, rule = null;
+    if (agent === 'auto') {
+      const r = route(this.cfg, prompt, avail);
+      agent = r.agent;
+      cwd = cwd || r.cwd;
+      rule = r.rule;
+    }
+    if (!['claude', 'codex', 'demo', 'grok', 'antigravity', 'ollama'].includes(agent)) throw httpErr(400, 'Tria Claude Code, Codex o «automàtic»');
+    if (!cwd) cwd = this.cfg.roots?.[0];
+    if (!cwd || !fs.existsSync(cwd)) throw httpErr(400, 'Aquesta carpeta no existeix');
+    if (b.after && !this.get(b.after)) throw httpErr(400, 'La feina anterior no existeix');
+    let at = b.at ? Number(new Date(b.at)) : null;
+    if (b.at && !Number.isFinite(at)) throw httpErr(400, 'La data no és vàlida');
+    if (b.cron) parseCron(b.cron);
+    const j = {
+      id: rid(),
+      title: String(b.title || prompt.replace(/\s+/g, ' ').slice(0, 70)),
+      prompt: prompt.slice(0, 20000),
+      agent,
+      cwd: path.resolve(cwd),
+      mode: ['llegir', 'preguntar', 'tot'].includes(b.mode) ? b.mode : 'preguntar',
+      model: String(b.model || '').slice(0, 80),
+      rule,
+      after: b.after || null,
+      always: !!b.always,
+      cron: b.cron || null,
+      state: b.cron ? 'programada' : 'pendent',
+      runAt: b.cron ? nextCron(b.cron) : at,
+      created: Date.now(),
+    };
+    this.jobs.push(j);
+    this.save();
+    this.emit(j);
+    this.audit.add({ type: 'job', what: `Feina ${j.cron ? 'programada' : 'a la cua'}: ${j.title}`, agent: j.agent, why: rule ? `Regla «${rule}»` : undefined, job: j.id });
+    this.tick();
+    return j;
+  }
+
+  cancel(id) {
+    const j = this.get(id);
+    if (!j) throw httpErr(404, 'Aquesta feina no existeix');
+    if (j.state === 'en curs' && j.session) this.hub.stop(j.session);
+    if (j.state === 'programada' || ACTIVE.has(j.state)) this.finish(j, 'cancel·lada', 'L’has cancel·lada');
+    return j;
+  }
+
+  remove(id) {
+    const j = this.get(id);
+    if (!j) throw httpErr(404, 'Aquesta feina no existeix');
+    if (ACTIVE.has(j.state) || j.state === 'programada') this.cancel(id);
+    this.jobs = this.jobs.filter((x) => x.id !== id);
+    this.save();
+    this.hub.emit('out', { type: 'job', removed: id });
+    return { ok: true };
+  }
+
+  runNow(id) {
+    const j = this.get(id);
+    if (!j) throw httpErr(404, 'Aquesta feina no existeix');
+    if (j.state === 'programada') return this.spawnFrom(j);
+    if (j.state !== 'pendent') throw httpErr(409, 'Aquesta feina ja ha començat');
+    j.runAt = null;
+    j.after = null;
+    this.tick();
+    return j;
+  }
+
+  // Una programació periòdica crea una feina nova cada vegada que toca.
+  spawnFrom(t) {
+    const j = { ...t, id: rid(), cron: null, from: t.id, state: 'pendent', runAt: null, created: Date.now() };
+    this.jobs.push(j);
+    this.emit(j);
+    this.save();
+    this.tick();
+    return j;
+  }
+
+  tick(now = Date.now()) {
+    let changed = false;
+    for (const t of this.jobs) {
+      if (t.state === 'programada' && t.runAt && t.runAt <= now) {
+        t.runAt = nextCron(t.cron, now);
+        t.lastFired = now;
+        this.spawnFrom(t);
+        changed = true;
+      }
+    }
+    const running = this.jobs.filter((j) => j.state === 'en curs').length;
+    let free = Math.max(0, (this.cfg.jobs?.max || 2) - running);
+    for (const j of this.jobs) {
+      if (j.state !== 'pendent' || free <= 0) continue;
+      if (j.runAt && j.runAt > now) continue;
+      if (j.after) {
+        const p = this.get(j.after);
+        if (!p || p.state === 'cancel·lada' || (p.state === 'fallada' && !j.always)) {
+          this.finish(j, 'cancel·lada', p ? `La feina anterior (${p.title}) no ha acabat bé` : 'La feina anterior ja no hi és');
+          changed = true;
+          continue;
+        }
+        if (p.state !== 'feta' && p.state !== 'fallada') continue;
+      }
+      this.start(j);
+      free--;
+      changed = true;
+    }
+    if (changed) this.save();
+  }
+
+  start(j) {
+    const prev = j.after ? this.get(j.after) : null;
+    const text = j.prompt.replace(/\{\{\s*anterior\s*\}\}/g, prev?.result || '(la feina anterior no ha deixat cap resposta)');
+    try {
+      const s = this.hub.create({ agent: j.agent, cwd: j.cwd, title: `⚙ ${j.title}`, mode: j.mode, model: j.model });
+      j.session = s.id;
+      j.state = 'en curs';
+      j.started = Date.now();
+      this.emit(j);
+      this.hub.send(s.id, text, this.hookUrl ? this.hookUrl() : undefined);
+    } catch (e) {
+      this.finish(j, 'fallada', e.message);
+    }
+  }
+
+  onHub(m) {
+    if (m.type !== 'event' || m.event?.kind !== 'status') return;
+    const j = this.jobs.find((x) => x.session === m.session && x.state === 'en curs');
+    if (!j || m.event.state === 'running') return;
+    const s = this.hub.get(m.session);
+    const last = s ? [...s.events].reverse().find((e) => e.kind === 'text') : null;
+    j.result = last ? String(last.text).slice(0, 8000) : '';
+    if (m.event.state === 'error') this.finish(j, 'fallada', s ? [...s.events].reverse().find((e) => e.kind === 'error')?.text : 'Error');
+    else if (m.event.code === 130 || m.event.code === 143) this.finish(j, 'cancel·lada', 'L’has aturat');
+    else this.finish(j, 'feta');
+    setImmediate(() => this.tick());
+  }
+
+  finish(j, state, error, quiet) {
+    j.state = state;
+    j.finished = Date.now();
+    if (error) j.error = String(error).slice(0, 500);
+    this.emit(j);
+    this.save();
+    if (quiet) return;
+    this.audit.add({ type: 'job', what: `${state === 'feta' ? 'Feina feta' : state === 'fallada' ? 'Feina fallada' : 'Feina cancel·lada'}: ${j.title}`, agent: j.agent, why: j.error, session: j.session, job: j.id });
+    if (state !== 'cancel·lada') this.hub.notice(this.hub.get(j.session), state === 'feta' ? 'Feina feta' : 'Una feina ha fallat', j.title, { job: j.id });
+  }
+
+  routes() {
+    return [
+      { method: 'GET', path: '/api/jobs', handler: () => ({ jobs: this.list(), routing: this.cfg.routing || [], max: this.cfg.jobs?.max || 2 }) },
+      { method: 'POST', path: '/api/jobs', handler: ({ body }) => this.add(body) },
+      { method: 'POST', path: /^\/api\/jobs\/([\w-]+)\/run$/, handler: ({ params }) => this.runNow(params[0]) },
+      { method: 'POST', path: /^\/api\/jobs\/([\w-]+)\/cancel$/, handler: ({ params }) => this.cancel(params[0]) },
+      { method: 'DELETE', path: /^\/api\/jobs\/([\w-]+)$/, handler: ({ params }) => this.remove(params[0]) },
+      {
+        method: 'PUT',
+        path: '/api/jobs/routing',
+        handler: ({ body }) => {
+          const rules = (Array.isArray(body.rules) ? body.rules : []).slice(0, 50).map((r) => ({ match: String(r.match || '').slice(0, 200), agent: String(r.agent || ''), cwd: r.cwd ? String(r.cwd) : undefined }));
+          for (const r of rules) {
+            try { new RegExp(r.match, 'i'); } catch { throw httpErr(400, `Regla no vàlida: «${r.match}»`); }
+          }
+          this.cfg.routing = rules;
+          require('./config').save(this.cfg);
+          return { routing: rules };
+        },
+      },
+    ];
+  }
+
+  startTimer() {
+    this.timer = setInterval(() => this.tick(), 15000);
+    this.timer.unref();
+  }
+}
+
+module.exports = { Jobs, parseCron, nextCron, route };

package/src/mcp.js

@@ -0,0 +1,142 @@
+'use strict';
+// Servidor MCP (stdio) de nio: la memòria compartida per a Claude Code i Codex.
+// Claude Code i Codex l'engeguen amb `nio mcp`; parla JSON-RPC 2.0, un missatge per línia.
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+const memory = require('./memory');
+
+const TOOLS = [
+  {
+    name: 'memoria_llista',
+    description: 'Llista els fitxers de la memòria compartida de nio (markdown). Fes-la servir per saber què hi ha abans de llegir o escriure.',
+    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+    run: () => {
+      const files = memory.list();
+      return files.length ? files.map((f) => `${f.path}  (${f.size} B)`).join('\n') : 'La memòria és buida.';
+    },
+  },
+  {
+    name: 'memoria_llegeix',
+    description: 'Llegeix un fitxer de la memòria compartida, p. ex. «preferencies.md» o «projectes/web.md».',
+    inputSchema: { type: 'object', properties: { fitxer: { type: 'string', description: 'Ruta relativa, acabada en .md' } }, required: ['fitxer'], additionalProperties: false },
+    run: ({ fitxer }) => memory.read(fitxer).content,
+  },
+  {
+    name: 'memoria_cerca',
+    description: 'Busca text a tota la memòria compartida (no distingeix majúscules ni accents). Retorna fitxer, línia i text.',
+    inputSchema: { type: 'object', properties: { text: { type: 'string' } }, required: ['text'], additionalProperties: false },
+    run: ({ text }) => {
+      const hits = memory.search(text);
+      return hits.length ? hits.map((h) => `${h.path}:${h.line}: ${h.text}`).join('\n') : 'Cap resultat.';
+    },
+  },
+  {
+    name: 'memoria_escriu',
+    description: 'Desa informació útil per a més endavant a la memòria compartida (la llegiran també els altres agents). Per defecte afegeix al final; amb mode «substitueix» reescriu el fitxer sencer. Desa-hi fets durables (preferències, decisions, context de projectes), no converses.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        fitxer: { type: 'string', description: 'Ruta relativa acabada en .md, p. ex. «projectes/botiga.md»' },
+        text: { type: 'string' },
+        mode: { type: 'string', enum: ['afegeix', 'substitueix'], default: 'afegeix' },
+      },
+      required: ['fitxer', 'text'],
+      additionalProperties: false,
+    },
+    run: ({ fitxer, text, mode }) => {
+      const r = memory.write(fitxer, text, { append: mode !== 'substitueix' });
+      return `Desat a ${r.path} (${r.size} B).`;
+    },
+  },
+];
+
+function serve({ input = process.stdin, output = process.stdout } = {}) {
+  const send = (msg) => output.write(`${JSON.stringify({ jsonrpc: '2.0', ...msg })}\n`);
+  const handle = (msg) => {
+    const { id, method, params } = msg;
+    const reply = (result) => id !== undefined && send({ id, result });
+    const fail = (code, message) => id !== undefined && send({ id, error: { code, message } });
+    switch (method) {
+      case 'initialize':
+        return reply({
+          protocolVersion: params?.protocolVersion || '2025-06-18',
+          capabilities: { tools: {} },
+          serverInfo: { name: 'nio', version: require('../package.json').version },
+          instructions: 'Memòria compartida de nio (fitxers markdown en aquest ordinador). Consulta-la a l’inici d’una tasca (memoria_cerca o memoria_llegeix preferencies.md) i desa-hi el que valgui la pena recordar.',
+        });
+      case 'ping':
+        return reply({});
+      case 'tools/list':
+        return reply({ tools: TOOLS.map(({ run, ...t }) => t) });
+      case 'tools/call': {
+        const tool = TOOLS.find((t) => t.name === params?.name);
+        if (!tool) return fail(-32602, `Eina desconeguda: ${params?.name}`);
+        try {
+          return reply({ content: [{ type: 'text', text: String(tool.run(params.arguments || {})) }] });
+        } catch (e) {
+          return reply({ content: [{ type: 'text', text: e.message }], isError: true });
+        }
+      }
+      default:
+        if (method && method.startsWith('notifications/')) return undefined;
+        return fail(-32601, `Mètode desconegut: ${method}`);
+    }
+  };
+  let buf = '';
+  input.setEncoding('utf8');
+  input.on('data', (d) => {
+    buf += d;
+    let i;
+    while ((i = buf.indexOf('\n')) >= 0) {
+      const line = buf.slice(0, i).trim();
+      buf = buf.slice(i + 1);
+      if (!line) continue;
+      let msg;
+      try {
+        msg = JSON.parse(line);
+      } catch {
+        send({ id: null, error: { code: -32700, message: 'JSON no vàlid' } });
+        continue;
+      }
+      for (const m of Array.isArray(msg) ? msg : [msg]) handle(m);
+    }
+  });
+}
+
+// ---------- registre a Claude Code i Codex (un sol cop, sense duplicar)
+function command() {
+  const entry = fs.realpathSync(path.join(__dirname, '..', 'bin', 'nio.js'));
+  return { cmd: process.execPath, args: [entry, 'mcp'], unstable: entry.includes(`${path.sep}_npx${path.sep}`) };
+}
+
+function registerClaude(bin, { force } = {}) {
+  if (!bin) return 'Claude Code no hi és';
+  const { cmd, args } = command();
+  if (!force && spawnSync(bin, ['mcp', 'get', 'nio'], { encoding: 'utf8', timeout: 15000 }).status === 0) return 'ja hi era';
+  spawnSync(bin, ['mcp', 'remove', '--scope', 'user', 'nio'], { timeout: 15000 });
+  const env = process.env.NIO_HOME ? ['-e', `NIO_HOME=${process.env.NIO_HOME}`] : [];
+  const r = spawnSync(bin, ['mcp', 'add', 'nio', '--scope', 'user', ...env, '--', cmd, ...args], { encoding: 'utf8', timeout: 15000 });
+  return r.status === 0 ? 'afegit' : `no s’ha pogut afegir: ${(r.stderr || r.stdout || '').trim().split('\n').pop()}`;
+}
+
+function registerCodex() {
+  const dir = path.join(process.env.CODEX_HOME || path.join(os.homedir(), '.codex'));
+  const file = path.join(dir, 'config.toml');
+  let txt = '';
+  try {
+    txt = fs.readFileSync(file, 'utf8');
+  } catch {
+    /* encara no hi és */
+  }
+  if (/^\s*\[mcp_servers\.nio\]/m.test(txt)) return 'ja hi era';
+  const { cmd, args } = command();
+  const q = (s) => JSON.stringify(s);
+  const block = `\n# Memòria compartida de nio (afegit per nio; ho pots treure quan vulguis)\n[mcp_servers.nio]\ncommand = ${q(cmd)}\nargs = [${args.map(q).join(', ')}]\n${process.env.NIO_HOME ? `env = { NIO_HOME = ${q(process.env.NIO_HOME)} }\n` : ''}`;
+  fs.mkdirSync(dir, { recursive: true });
+  fs.appendFileSync(file, `${txt && !txt.endsWith('\n') ? '\n' : ''}${block}`);
+  return 'afegit';
+}
+
+module.exports = { serve, TOOLS, registerClaude, registerCodex, command };