nio-cat 0.9.15 → 0.9.16

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 { Learner } = require('../src/learn');
 const { Notes } = require('../src/notes');
 const { Call } = require('../src/call');
 const mcp = require('../src/mcp');
@@ -217,7 +218,8 @@ async function start() {
   const remote = new Remote({ cfg, audit });
   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 learner = new Learner(hub);
+  const routes = [...learner.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.15",
+  "version": "0.9.16",
   "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

@@ -25,7 +25,9 @@ module.exports = {
     if (session.nativeId && session.forkNative) { args.push('--fork-session'); delete session.forkNative; }
     if (session.model) args.push('--model', session.model);
     // Que l'agent posi un títol que resumeixi la feina (eina MCP de nio; el hub el desa).
-    args.push('--append-system-prompt', 'Treballes dins una sessió de nio. Quan entenguis la tasca, crida l’eina mcp__nio__sessio_titol amb un títol de 3-7 paraules que la resumeixi, en l’idioma de l’usuari; torna-la a cridar només si la feina canvia de tema.');
+    // A la primera crida, també el que ja recorda la memòria compartida d'aquest projecte.
+    const mem = session.nativeId || cfg.memory?.context === false ? '' : require('../learn').context(session.cwd);
+    args.push('--append-system-prompt', `Treballes dins una sessió de nio. Quan entenguis la tasca, crida l’eina mcp__nio__sessio_titol amb un títol de 3-7 paraules que la resumeixi, en l’idioma de l’usuari; torna-la a cridar només si la feina canvia de tema.${mem ? `\n\n${mem}` : ''}`);
 
     // Com a root (un VPS), Claude Code no accepta bypassPermissions: «Via lliure» hi fa servir el mode auto,
     // que també treballa sol però fa revisar cada acció a un classificador (el mateix que el Claude Code remot).

package/src/agents/codex.js

@@ -19,7 +19,9 @@ module.exports = {
     if (session.model) args.push('--model', session.model);
     for (const a of (cfg.agents?.codex?.extraArgs || [])) args.push(a);
     if (session.nativeId) args.push('resume', session.nativeId);
-    args.push(prompt);
+    // Codex no té indicacions de sistema en mode exec: el context de la memòria va davant del primer missatge.
+    const mem = session.nativeId || cfg.memory?.context === false ? '' : require('../learn').context(session.cwd);
+    args.push(mem ? `${mem}\n\n---\n\n${prompt}` : prompt);
 
     const started = new Set();
     return run({

package/src/hub.js

@@ -335,6 +335,7 @@ class Hub extends EventEmitter {
         s.state = code === 130 || code === 143 ? 'idle' : code && code !== 0 ? 'error' : 'idle';
         this.push(s, 'status', { state: s.state, code });
         this.notice(s, s.state === 'error' ? 'Hi ha hagut un error' : 'Feina acabada', s.title);
+        if (s.state === 'idle') this.emit('finished', s); // la memòria n'aprèn (learn.js)
       },
     };
 

package/src/learn.js

@@ -0,0 +1,417 @@
+'use strict';
+// Memòria que aprèn sola: quan una sessió acaba, un model petit (Claude Code en mode headless, sense eines)
+// llegeix la conversa i en treu els fets durables. Els nous es desen a la memòria; els que en contradiuen
+// un d'existent queden pendents perquè decideixis tu des de l'app (Memòria).
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const memory = require('./memory');
+const { HOME, save } = require('./config');
+
+const FILE = path.join(HOME, 'memory-learn.json');
+const DELAY = Number(process.env.NIO_LEARN_DELAY) || 2 * 60 * 1000; // espera que la sessió reposi
+const MAX_CHAT = 40000; // caràcters de conversa que es llegeixen
+const MAX_MEM = 30000; // caràcters de memòria que es passen per comparar
+const MAX_LOG = 200;
+
+const norm = (s) => String(s).toLowerCase().normalize('NFD').replace(/[̀-ͯ]/g, '').replace(/[^\p{L}\p{N}]+/gu, ' ').trim();
+const slug = (s) => norm(s).replace(/\s+/g, '-');
+const uid = () => crypto.randomBytes(6).toString('base64url');
+
+function load() {
+  try { return { pending: [], log: [], ...JSON.parse(fs.readFileSync(FILE, 'utf8')) }; } catch { return { pending: [], log: [] }; }
+}
+function store(st) {
+  st.log = st.log.slice(-MAX_LOG);
+  fs.writeFileSync(FILE, JSON.stringify(st, null, 2), { mode: 0o600 });
+}
+
+// ---------- context per a l'inici d'una sessió ----------
+// Fitxer del projecte d'una carpeta: projectes/<nom de la carpeta>.md (o el que s'hi assembli).
+function projectFile(cwd) {
+  const base = slug(path.basename(String(cwd || '')));
+  if (!base) return null;
+  const files = memory.list().map((f) => f.path).filter((p) => p.startsWith('projectes/'));
+  return files.find((p) => slug(path.basename(p, '.md')) === base) || null;
+}
+function suggestedFile(cwd) {
+  return projectFile(cwd) || `projectes/${path.basename(String(cwd || '')).replace(/[^\p{L}\p{N} _.,()'’-]+/gu, '-') || 'general'}.md`;
+}
+
+// Text que es dona a l'agent abans de començar: preferències, el fitxer del projecte i què més hi ha.
+function context(cwd, max = 8000) {
+  try {
+    memory.ensure();
+    const parts = [];
+    const add = (p) => { try { const t = memory.read(p).content.trim(); if (t) parts.push(`--- ${p} ---\n${t}`); } catch { /* no hi és */ } };
+    add('preferencies.md');
+    const pf = projectFile(cwd);
+    if (pf) add(pf);
+    let txt = parts.join('\n\n');
+    if (txt.length > max) txt = `${txt.slice(0, max)}\n… (retallat: llegeix el fitxer sencer amb memoria_llegeix)`;
+    const others = memory.list().map((f) => f.path).filter((p) => p !== 'preferencies.md' && p !== pf && p !== 'LLEGEIX-ME.md');
+    if (!txt && !others.length) return '';
+    return `Memòria compartida de nio (la mantenen tots els teus agents; fes-la servir i, si hi veus res obsolet, corregeix-ho amb memoria_corregeix):\n\n${txt || '(encara no hi ha res d’aquest projecte)'}${others.length ? `\n\nAltres fitxers de memòria (llegeix-los amb memoria_llegeix si et calen): ${others.slice(0, 60).join(', ')}` : ''}`;
+  } catch {
+    return '';
+  }
+}
+
+// ---------- el model ----------
+// Crida Claude Code sense eines ni MCP ni sessió desada i en retorna la sortida estructurada.
+function askClaude(cfg, prompt, schema) {
+  const { binPath } = require('./agents');
+  const { run } = require('./proc');
+  const bin = binPath(cfg, 'claude');
+  if (!bin) return Promise.reject(new Error('Cal Claude Code en aquest ordinador perquè la memòria aprengui sola'));
+  const model = cfg.memory?.model || 'haiku';
+  const args = ['-p', '--model', model, '--tools', '', '--strict-mcp-config', '--no-session-persistence', '--setting-sources', '', '--output-format', 'json', '--json-schema', JSON.stringify(schema)];
+  return new Promise((resolve, reject) => {
+    const out = [];
+    const errs = [];
+    const h = run({
+      bin, args, cwd: memory.DIR, stdin: prompt,
+      onLine: (l) => out.push(l),
+      onErr: (l) => errs.push(l),
+      onExit: (code, err) => {
+        clearTimeout(timer);
+        if (err) return reject(err);
+        let r = null;
+        for (const l of out.reverse()) { try { r = JSON.parse(l); break; } catch { /* no és JSON */ } }
+        if (!r || r.is_error) return reject(new Error((r && r.result) || errs.slice(-1)[0] || `Claude Code ha acabat amb el codi ${code}`));
+        let data = r.structured_output;
+        if (!data && typeof r.result === 'string') { try { data = JSON.parse(r.result.replace(/^```(?:json)?\s*|\s*```$/g, '')); } catch { /* res */ } }
+        if (!data) return reject(new Error('El model no ha retornat res que s’entengui'));
+        resolve({ data, cost: r.total_cost_usd || 0 });
+      },
+    });
+    const timer = setTimeout(() => h.kill(), 3 * 60 * 1000);
+  });
+}
+
+const FACTS = {
+  type: 'object',
+  properties: {
+    fets: {
+      type: 'array',
+      maxItems: 10,
+      items: {
+        type: 'object',
+        properties: {
+          fitxer: { type: 'string', description: 'Ruta relativa acabada en .md' },
+          text: { type: 'string', description: 'El fet, una sola línia curta' },
+          antic: { type: 'string', description: 'Només si contradiu o substitueix una línia que ja és a la memòria: aquella línia, copiada exactament' },
+        },
+        required: ['fitxer', 'text'],
+      },
+    },
+  },
+  required: ['fets'],
+};
+
+const RULES = `Regles:
+- Desa només fets durables que serviran en sessions futures a qualsevol agent: preferències de l'usuari, decisions preses, com es fa una cosa en un projecte (ordres, desplegament, rutes, comptes, convencions), errors que no s'han de repetir, persones i el seu rol.
+- No desis l'estat de la feina d'avui, resums de la conversa, coses que ja diu el codi o la memòria, ni secrets (contrasenyes, tokens, claus).
+- Cada fet és una línia curta i autònoma (s'ha d'entendre sense la conversa), en l'idioma de l'usuari. Si cal, afegeix la data.
+- Si un fet nou contradiu o deixa obsoleta una línia de la memòria, posa aquella línia exacta a «antic».
+- Fitxers: preferències generals → preferencies.md; persones → persones/<nom>.md; un projecte → projectes/<nom>.md.
+- Si no hi ha res que valgui la pena, retorna una llista buida. Millor poc i bo que molt.`;
+
+function memoryDump(max = MAX_MEM, first = []) {
+  const files = memory.list().map((f) => f.path).filter((p) => p !== 'LLEGEIX-ME.md');
+  const order = [...new Set([...first.filter((p) => files.includes(p)), ...files])];
+  let out = '';
+  for (const p of order) {
+    let t = '';
+    try { t = memory.read(p).content.trim(); } catch { continue; }
+    if (!t) continue;
+    const block = `--- ${p} ---\n${t}\n\n`;
+    if (out.length + block.length > max) { out += `--- ${p} --- (no hi cap)\n`; continue; }
+    out += block;
+  }
+  return out.trim() || '(buida)';
+}
+
+function transcript(s, fromSeq) {
+  const evs = s.events.filter((e) => e.seq > fromSeq && (e.kind === 'user' || e.kind === 'text' || e.kind === 'tool'));
+  const lines = evs.map((e) => (e.kind === 'user' ? `USUARI: ${e.text}` : e.kind === 'text' ? `AGENT: ${e.text}` : `(eina ${e.name}: ${String(e.input?.command || e.input?.file_path || e.input?.description || '').slice(0, 160)})`));
+  let txt = lines.join('\n\n');
+  if (txt.length > MAX_CHAT) txt = `… (comença a mitja conversa)\n${txt.slice(-MAX_CHAT)}`;
+  return { txt, users: evs.filter((e) => e.kind === 'user').length };
+}
+
+// ---------- desar ----------
+function lines(file) {
+  try { return memory.read(file).content.split('\n'); } catch { return null; }
+}
+function hasLine(file, text) {
+  const n = norm(text);
+  return (lines(file) || []).some((l) => norm(l.replace(/^\s*[-*]\s+/, '')) === n);
+}
+function findLine(file, text) {
+  const n = norm(String(text).replace(/^\s*[-*]\s+/, ''));
+  if (!n) return -1;
+  const ls = lines(file) || [];
+  const i = ls.findIndex((l) => norm(l.replace(/^\s*[-*]\s+/, '')) === n);
+  return i >= 0 ? i : ls.findIndex((l) => n.length > 12 && norm(l).includes(n));
+}
+function appendFact(file, text) {
+  const exists = lines(file);
+  const head = exists ? '' : `# ${path.basename(file, '.md').replace(/^./, (c) => c.toUpperCase())}\n\n`;
+  memory.write(file, `${head}- ${text}`, { append: true });
+}
+// Substitueix una línia (per text exacte) i en manté la vinyeta.
+function replaceLine(file, old, text) {
+  const ls = lines(file);
+  const i = ls ? findLine(file, old) : -1;
+  if (i < 0) return false;
+  const bullet = (ls[i].match(/^\s*[-*]\s+/) || ['- '])[0];
+  ls[i] = `${bullet}${text}`;
+  memory.write(file, ls.join('\n'));
+  return true;
+}
+function removeLine(file, text) {
+  const ls = lines(file);
+  const i = ls ? findLine(file, text) : -1;
+  if (i < 0) return false;
+  ls.splice(i, 1);
+  memory.write(file, ls.join('\n'));
+  return true;
+}
+
+function cleanFact(f) {
+  const text = String(f.text || '').replace(/\s+/g, ' ').replace(/^[-*]\s+/, '').trim().slice(0, 400);
+  let file;
+  try { file = memory.safe(String(f.fitxer || '').trim()).rel; } catch { file = null; }
+  const antic = String(f.antic || '').replace(/^\s*[-*]\s+/, '').trim();
+  return { text, file, antic };
+}
+
+// Aplica el que ha trobat el model: fets nous a la memòria, contradiccions a la safata.
+function apply(st, facts, meta, fallbackFile) {
+  const added = [];
+  const conflicts = [];
+  for (const raw of facts || []) {
+    const f = cleanFact(raw);
+    if (!f.text) continue;
+    const file = f.file || fallbackFile;
+    if (/(?:token|password|contrasenya|secret|api[_ -]?key)\s*[:=]\s*\S{8,}/i.test(f.text)) continue; // mai secrets
+    if (f.antic) {
+      // On és la línia antiga? Al fitxer proposat o a qualsevol altre.
+      const where = [file, ...memory.list().map((x) => x.path)].find((p) => findLine(p, f.antic) >= 0);
+      if (where && norm(f.antic) !== norm(f.text)) {
+        if (st.pending.some((p) => p.file === where && norm(p.old) === norm(f.antic) && norm(p.new) === norm(f.text))) continue;
+        const ls = lines(where);
+        const p = { id: uid(), t: Date.now(), file: where, old: ls[findLine(where, f.antic)].replace(/^\s*[-*]\s+/, '').trim(), new: f.text, ...meta };
+        st.pending.push(p);
+        conflicts.push(p);
+        continue;
+      }
+    }
+    if (hasLine(file, f.text)) continue;
+    appendFact(file, f.text);
+    const e = { id: uid(), t: Date.now(), file, text: f.text, ...meta };
+    st.log.push(e);
+    added.push(e);
+  }
+  return { added, conflicts };
+}
+
+// ---------- el motor ----------
+class Learner {
+  constructor(hub, { ask } = {}) {
+    this.hub = hub;
+    this.cfg = hub.cfg;
+    this.ask = ask || ((prompt, schema) => askClaude(this.cfg, prompt, schema));
+    this.timers = new Map();
+    this.busy = new Set();
+    this.reviewing = false;
+    hub.on('finished', (s) => this.schedule(s));
+  }
+
+  enabled() {
+    return this.cfg.memory?.auto !== false;
+  }
+
+  schedule(s) {
+    if (!this.enabled() || s.agent === 'demo' || s.noLearn) return;
+    clearTimeout(this.timers.get(s.id));
+    const t = setTimeout(() => {
+      this.timers.delete(s.id);
+      if (this.hub.runs.has(s.id)) return; // torna a treballar: ja s'avisarà quan acabi
+      this.learn(s.id).catch(() => {});
+    }, DELAY);
+    t.unref?.();
+    this.timers.set(s.id, t);
+  }
+
+  async learn(sid) {
+    const s = this.hub.get(sid);
+    if (!s || this.busy.has(sid)) return null;
+    const from = s.memSeq || 0;
+    const { txt, users } = transcript(s, from);
+    if (!users || txt.length < 200) return null;
+    this.busy.add(sid);
+    const upto = s.seq;
+    try {
+      const file = suggestedFile(s.cwd);
+      const prompt = `Ets la memòria d'un equip d'agents de programació (Claude Code, Codex…) que treballen per la mateixa persona. Llegeix aquesta sessió i treu-ne els fets que convé recordar perquè la propera sessió de qualsevol agent comenci sabent-los.
+
+Avui és ${new Date().toISOString().slice(0, 10)}.
+Carpeta de la sessió: ${s.cwd} (el fitxer d'aquest projecte és ${file})
+Títol: ${s.title || '—'}
+
+${RULES}
+
+MEMÒRIA ACTUAL:
+${memoryDump(MAX_MEM, ['preferencies.md', file])}
+
+SESSIÓ:
+${txt}`;
+      const { data, cost } = await this.ask(prompt, FACTS);
+      const st = load();
+      const r = apply(st, data.fets, { session: s.id, title: s.title || '', agent: s.agent }, file);
+      store(st);
+      s.memSeq = upto;
+      this.hub.persist(s);
+      if (cost) this.hub.emit('out', { type: 'memory', cost });
+      if (r.added.length || r.conflicts.length) {
+        this.hub.emit('out', { type: 'memory', added: r.added.length, conflicts: r.conflicts.length });
+        this.hub.push(s, 'info', { text: `Memòria: ${[r.added.length && `${r.added.length} ${r.added.length === 1 ? 'fet nou' : 'fets nous'}`, r.conflicts.length && `${r.conflicts.length} ${r.conflicts.length === 1 ? 'contradicció per revisar' : 'contradiccions per revisar'}`].filter(Boolean).join(' · ')}`, memory: true });
+      }
+      if (r.conflicts.length) this.hub.notice(s, 'La memòria té una contradicció', `${r.conflicts[0].old} → ${r.conflicts[0].new}`, { route: 'memoria' });
+      return r;
+    } finally {
+      this.busy.delete(sid);
+    }
+  }
+
+  // Repassa tota la memòria: contradiccions i duplicats entre fitxers.
+  async review() {
+    if (this.reviewing) throw Object.assign(new Error('Ja s’està revisant'), { status: 409 });
+    this.reviewing = true;
+    try {
+      const schema = {
+        type: 'object',
+        properties: {
+          problemes: {
+            type: 'array',
+            maxItems: 15,
+            items: {
+              type: 'object',
+              properties: {
+                fitxer: { type: 'string' },
+                antic: { type: 'string', description: 'La línia obsoleta o duplicada, copiada exactament' },
+                text: { type: 'string', description: 'Com hauria de quedar (buit per esborrar-la si és un duplicat)' },
+                motiu: { type: 'string', description: 'Per què, en poques paraules' },
+              },
+              required: ['fitxer', 'antic', 'text', 'motiu'],
+            },
+          },
+        },
+        required: ['problemes'],
+      };
+      const prompt = `Avui és ${new Date().toISOString().slice(0, 10)}. Revisa la memòria compartida d'aquests agents. Busca línies que es contradiguin entre si (dins un fitxer o entre fitxers), que una altra línia hagi deixat obsoletes (mira les dates) o que estiguin duplicades. Per a cada problema, indica la línia que cal canviar («antic», copiada exactament), com hauria de quedar («text»; buit si és un duplicat que cal treure) i el motiu. No proposis canvis d'estil ni de redacció. Si no hi ha cap problema, retorna una llista buida.
+
+MEMÒRIA:
+${memoryDump(MAX_MEM * 2)}`;
+      const { data } = await this.ask(prompt, schema);
+      const st = load();
+      const found = [];
+      for (const p of data.problemes || []) {
+        const f = cleanFact({ fitxer: p.fitxer, text: p.text, antic: p.antic });
+        const where = [f.file, ...memory.list().map((x) => x.path)].filter(Boolean).find((x) => findLine(x, f.antic) >= 0);
+        if (!where || norm(f.antic) === norm(f.text)) continue;
+        if (st.pending.some((x) => x.file === where && norm(x.old) === norm(f.antic))) continue;
+        const item = { id: uid(), t: Date.now(), file: where, old: lines(where)[findLine(where, f.antic)].replace(/^\s*[-*]\s+/, '').trim(), new: f.text, why: String(p.motiu || '').slice(0, 200), review: true };
+        st.pending.push(item);
+        found.push(item);
+      }
+      store(st);
+      return { found: found.length, pending: st.pending };
+    } finally {
+      this.reviewing = false;
+    }
+  }
+
+  status() {
+    const st = load();
+    return { auto: this.enabled(), pending: st.pending, log: st.log.slice(-40).reverse(), reviewing: this.reviewing, learning: this.busy.size };
+  }
+
+  // choice: «nou» (fes servir el nou), «antic» (mantén el que hi havia) o «tots» (desa el nou com a línia a part).
+  resolve(id, choice) {
+    const st = load();
+    const p = st.pending.find((x) => x.id === id);
+    if (!p) throw Object.assign(new Error('Aquesta proposta ja no hi és'), { status: 404 });
+    if (choice === 'nou') {
+      const ok = p.new ? replaceLine(p.file, p.old, p.new) : removeLine(p.file, p.old);
+      if (!ok && p.new && !hasLine(p.file, p.new)) appendFact(p.file, p.new);
+      if (p.new) st.log.push({ id: uid(), t: Date.now(), file: p.file, text: p.new, replaced: p.old, session: p.session, title: p.title, agent: p.agent });
+    } else if (choice === 'tots') {
+      if (p.new && !hasLine(p.file, p.new)) appendFact(p.file, p.new);
+    } else if (choice !== 'antic') {
+      throw Object.assign(new Error('Tria «nou», «antic» o «tots»'), { status: 400 });
+    }
+    st.pending = st.pending.filter((x) => x.id !== id);
+    store(st);
+    return { pending: st.pending };
+  }
+
+  // Desfà un fet après: el treu del fitxer (o hi torna a posar l'antic si n'havia substituït un).
+  undo(id) {
+    const st = load();
+    const e = st.log.find((x) => x.id === id);
+    if (!e) throw Object.assign(new Error('Aquest canvi ja no hi és'), { status: 404 });
+    const ok = e.replaced ? replaceLine(e.file, e.text, e.replaced) : removeLine(e.file, e.text);
+    st.log = st.log.filter((x) => x.id !== id);
+    store(st);
+    return { ok };
+  }
+
+  routes() {
+    const httpErr = (status, message) => Object.assign(new Error(message), { status });
+    return [
+      { method: 'GET', path: '/api/memory/learn', handler: () => this.status() },
+      {
+        method: 'PUT', path: '/api/memory/learn', handler: ({ body }) => {
+          if (typeof body?.auto !== 'boolean') throw httpErr(400, 'Falta «auto»');
+          this.cfg.memory = { ...(this.cfg.memory || {}), auto: body.auto };
+          save(this.cfg);
+          return this.status();
+        },
+      },
+      { method: 'POST', path: /^\/api\/memory\/pending\/([\w-]+)$/, handler: ({ params, body }) => this.resolve(params[0], body?.choice) },
+      { method: 'DELETE', path: /^\/api\/memory\/log\/([\w-]+)$/, handler: ({ params }) => this.undo(params[0]) },
+      { method: 'POST', path: '/api/memory/review', handler: () => this.review() },
+      {
+        method: 'POST', path: /^\/api\/memory\/learn\/([\w-]+)$/, handler: async ({ params }) => {
+          if (!this.hub.get(params[0])) throw httpErr(404, 'Aquesta sessió no existeix');
+          return (await this.learn(params[0])) || { added: [], conflicts: [] };
+        },
+      },
+    ];
+  }
+}
+
+// Línies de la memòria que s'assemblen a un text nou (per avisar l'agent que potser contradiu o repeteix).
+function similar(text, { skip } = {}) {
+  const words = (s) => new Set(norm(s).split(' ').filter((w) => w.length > 3));
+  const a = words(text);
+  if (a.size < 2) return [];
+  const out = [];
+  for (const f of memory.list()) {
+    (lines(f.path) || []).forEach((l, i) => {
+      if (skip && skip.file === f.path && skip.lines.has(l)) return;
+      const b = words(l);
+      if (b.size < 2) return;
+      let n = 0;
+      for (const w of a) if (b.has(w)) n++;
+      const score = n / Math.min(a.size, b.size);
+      if (n >= 2 && score >= 0.5) out.push({ path: f.path, line: i + 1, text: l.trim().slice(0, 300), score });
+    });
+  }
+  return out.sort((x, y) => y.score - x.score).slice(0, 5);
+}
+
+module.exports = { Learner, context, projectFile, suggestedFile, similar, apply, replaceLine, removeLine, askClaude, load, FILE };

package/src/mcp.js

@@ -47,7 +47,30 @@ const TOOLS = [
     },
     run: ({ fitxer, text, mode }) => {
       const r = memory.write(fitxer, text, { append: mode !== 'substitueix' });
-      return `Desat a ${r.path} (${r.size} B).`;
+      // Avisa si ja hi havia res semblant: potser és un duplicat o el nou contradiu l'antic.
+      const near = require('./learn').similar(text, { skip: { file: r.path, lines: new Set(String(text).split('\n')) } });
+      return `Desat a ${r.path} (${r.size} B).${near.length ? `\n\nAlerta: a la memòria ja hi ha línies semblants. Si el que acabes de desar les contradiu o les repeteix, corregeix-les amb memoria_corregeix:\n${near.map((h) => `${h.path}:${h.line}: ${h.text}`).join('\n')}` : ''}`;
+    },
+  },
+  {
+    name: 'memoria_corregeix',
+    description: 'Corregeix una línia de la memòria que ha quedat obsoleta o és falsa: substitueix-la pel text nou (o esborra-la si «nou» és buit). Fes-la servir en lloc d’afegir un fet que en contradigui un altre, perquè la memòria no tingui dues versions.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        fitxer: { type: 'string', description: 'Ruta relativa acabada en .md' },
+        antic: { type: 'string', description: 'La línia que cal canviar, tal com és ara (o un tros prou llarg per trobar-la)' },
+        nou: { type: 'string', description: 'Com ha de quedar; buit per esborrar-la' },
+      },
+      required: ['fitxer', 'antic', 'nou'],
+      additionalProperties: false,
+    },
+    run: ({ fitxer, antic, nou }) => {
+      const learn = require('./learn');
+      memory.read(fitxer); // 404 si no hi és
+      const ok = String(nou || '').trim() ? learn.replaceLine(memory.safe(fitxer).rel, antic, String(nou).trim()) : learn.removeLine(memory.safe(fitxer).rel, antic);
+      if (!ok) throw new Error(`No he trobat aquesta línia a ${fitxer}. Llegeix el fitxer amb memoria_llegeix i copia-la tal com és.`);
+      return String(nou || '').trim() ? `Corregit a ${fitxer}.` : `Esborrat de ${fitxer}.`;
     },
   },
   {
@@ -72,7 +95,7 @@ function serve({ input = process.stdin, output = process.stdout } = {}) {
           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. Si treballes dins una sessió de nio, posa-li un títol curt amb sessio_titol.',
+          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. Si un fet ha canviat, corregeix la línia antiga amb memoria_corregeix en lloc d’afegir-ne una de nova. Si treballes dins una sessió de nio, posa-li un títol curt amb sessio_titol.',
         });
       case 'ping':
         return reply({});

package/web/app/app.js

@@ -1142,8 +1142,29 @@ function viewMemory() {
   if (!machine()) return `<div class="top"><div><h1>Memòria</h1><p>El que recorden els teus agents: preferències, decisions i context dels projectes.</p></div></div>${noMachine('La memòria són fitxers a l’ordinador. Connecta’n un per veure-la i editar-la.')}`;
   return `<div class="top"><div><h1>Memòria</h1><p>Preferències, decisions i context que els agents recorden en aquest ordinador. Obre un fitxer per consultar-lo o editar-lo.</p></div><button class="btn ink" data-act="mem-new" type="button">${svg(ICON.plus)}Fitxer nou</button></div>
     <form class="mem-search" id="memSearch" role="search"><input type="search" id="memQ" placeholder="Busca a la memòria…" aria-label="Busca a la memòria" autocomplete="off"><button class="btn ink" type="submit">Busca</button></form>
+    <div id="memLearn">${learnHtml()}</div>
     <div id="memBody">${memHtml()}</div>`;
 }
+// La memòria que aprèn sola (learn.js): contradiccions per decidir, el que s'ha après i l'interruptor.
+let memLearn = null;
+function learnHtml() {
+  const L = memLearn;
+  if (!L || L.error) return '';
+  const pend = L.pending.map((p) => `<div class="card mem-conflict"><div class="muted small"><span class="mono">${esc(p.file)}</span>${p.title ? ` · ${esc(p.title)}` : ''}</div>
+    <div class="mem-old"><span class="muted small">Ara diu</span><s>${esc(p.old)}</s></div>
+    <div class="mem-new"><span class="muted small">${p.new ? 'Hauria de dir' : 'Proposta'}</span>${p.new ? esc(p.new) : '<i>Esborrar-la (repetida)</i>'}</div>
+    ${p.why ? `<div class="muted small">${esc(p.why)}</div>` : ''}
+    <div class="row wrap"><button class="btn ink sm" type="button" data-mem-pick="${esc(p.id)}:nou">${p.new ? 'Fes servir el nou' : 'Esborra-la'}</button><button class="btn sm" type="button" data-mem-pick="${esc(p.id)}:antic">Mantén l’antic</button>${p.new ? `<button class="btn ghost sm" type="button" data-mem-pick="${esc(p.id)}:tots">Desa’ls tots dos</button>` : ''}</div></div>`).join('');
+  const log = L.log.slice(0, 8).map((e) => `<div class="card row mem-learned"><span class="grow"><span class="small">${esc(e.text)}</span><div class="muted small"><span class="mono">${esc(e.file)}</span> · ${ago(e.t)}${e.replaced ? ' · substitueix una línia' : ''}</div></span><button class="btn ghost sm" type="button" data-mem-undo="${esc(e.id)}">Desfés</button></div>`).join('');
+  return `${pend ? `<div class="section-title">Contradiccions per revisar</div><div class="list mem-learn">${pend}</div>` : ''}
+    <div class="panel mem-auto"><label class="row check"><input type="checkbox" id="memAuto" ${L.auto ? 'checked' : ''}> <span><b>Aprèn sola de les sessions</b><span class="muted small block">Quan una sessió acaba, Claude (Haiku) en treu el que convé recordar. Les contradiccions no es canvien soles: te les deixa aquí.</span></span></label>
+    <button class="btn sm" type="button" data-act="mem-review" ${L.reviewing ? 'disabled' : ''}>${L.reviewing ? 'Revisant…' : 'Revisa la memòria'}</button></div>
+    ${log ? `<div class="section-title">Après fa poc</div><div class="list mem-learn">${log}</div>` : ''}`;
+}
+async function loadLearn() {
+  try { memLearn = await api('/api/memory/learn'); } catch (e) { memLearn = { error: e.message }; }
+  const box = $('#memLearn'); if (box) box.innerHTML = learnHtml();
+}
 function memHtml() {
   if (!mem) return `<div class="panel empty">${bot('work')}<h2>Carregant…</h2></div>`;
   if (mem.error) return `<div class="panel empty">${bot('sleep')}<h2>${esc(mem.error)}</h2><p>Cal nio 0.6 o més nou en aquest ordinador.</p></div>`;
@@ -1153,6 +1174,7 @@ function memHtml() {
   return Object.entries(groups).map(([g, fs]) => `${g ? `<div class="section-title">${esc(g)}</div>` : ''}<div class="list mem-list">${fs.map((f) => `<button class="card row" type="button" data-mem="${esc(f.path)}"><span class="grow"><b>${esc(f.path.split('/').pop().replace(/\.md$/, ''))}</b><div class="muted small">${ago(f.updated)} · ${bytes(f.size)}</div></span></button>`).join('')}</div>`).join('') || '<p class="muted">La memòria és buida.</p>';
 }
 async function loadMemory() {
+  loadLearn();
   try { mem = await api('/api/memory'); } catch (e) { mem = { error: e.message }; }
   const box = $('#memBody'); if (box) box.innerHTML = memHtml();
 }
@@ -1179,6 +1201,20 @@ async function memEdit(p) {
   });
 }
 document.addEventListener('click', (e) => { const b = e.target.closest('[data-mem]'); if (b) memEdit(b.dataset.mem); });
+document.addEventListener('click', async (e) => {
+  const pick = e.target.closest('[data-mem-pick]'), undo = e.target.closest('[data-mem-undo]');
+  if (!pick && !undo) return;
+  (pick || undo).disabled = true;
+  try {
+    if (pick) { const [id, choice] = pick.dataset.memPick.split(':'); await api(`/api/memory/pending/${id}`, { method: 'POST', body: { choice } }); toast(choice === 'antic' ? 'Es queda com estava' : 'Memòria actualitzada'); }
+    else { await api(`/api/memory/log/${undo.dataset.memUndo}`, { method: 'DELETE' }); toast('Desfet'); }
+  } catch (err) { toast(err.message); }
+  loadMemory();
+});
+document.addEventListener('change', async (e) => {
+  if (e.target.id !== 'memAuto') return;
+  try { memLearn = await api('/api/memory/learn', { method: 'PUT', body: { auto: e.target.checked } }); toast(e.target.checked ? 'La memòria aprendrà de les sessions' : 'Aprenentatge automàtic aturat'); } catch (err) { e.target.checked = !e.target.checked; toast(err.message); }
+});
 document.addEventListener('submit', async (e) => {
   if (e.target.id !== 'memSearch') return;
   e.preventDefault(); const q = $('#memQ').value.trim(); if (!q) return loadMemory();
@@ -1535,7 +1571,7 @@ function eventNode(e) {
     case 'tool_result': return el(`<details class="tool"><summary><span class="name">${esc(e.name || 'Eina')}</span><span class="arg"></span><span class="st ${e.error ? 'err' : 'ok'}">${e.error ? '✕' : '✓'}</span></summary><pre class="out">${esc(e.output)}</pre></details>`);
     case 'approval': { const a = state.approvals.get(e.approval) || {}; return el(approvalCard({ ...a, approval: e.approval, tool: e.tool, input: e.input, state: e.state && e.state !== 'pending' ? e.state : a.state || e.state }, false)); }
     case 'error': return el(`<div class="ev-error" role="alert"><b>Error</b><span>${esc(e.text)}</span></div>`);
-    case 'info': return el(`<div class="ev-info">${esc(e.text)}</div>`);
+    case 'info': return el(e.memory ? `<div class="ev-info">${esc(e.text)} · <button class="linkish" type="button" data-act="open-memory">Obre la memòria</button></div>` : `<div class="ev-info">${esc(e.text)}</div>`);
     case 'result': {
       const bits = [];
       if (e.ms) bits.push(`${(e.ms / 1000).toFixed(1).replace('.', ',')} s`);
@@ -2864,6 +2900,12 @@ document.addEventListener('click', async (e) => {
     case 'screen-now': return screenNow();
     case 'mem-new': return memEdit(null);
     case 'mem-all': if (mem) delete mem.hits; return loadMemory();
+    case 'mem-review': {
+      a.disabled = true; a.textContent = 'Revisant…';
+      try { const r = await api('/api/memory/review', { method: 'POST' }); toast(r.found ? `${r.found} ${r.found === 1 ? 'cosa' : 'coses'} per revisar` : 'Cap contradicció ni duplicat'); } catch (err) { toast(err.message); }
+      return loadMemory();
+    }
+    case 'open-memory': return go('#/memoria');
     case 'activity-refresh': activity = null; return loadActivity();
     case 'push-test': try { const r = await api('/api/push/test', { method: 'POST' }); toast(r.subs ? 'Enviat. Arribarà en uns segons.' : 'Primer activa els avisos'); } catch (err) { toast(err.message); } return;
     case 'add-computer': return addComputerSheet();

package/web/app/demo.js

@@ -305,8 +305,15 @@
   const noteId = () => Math.random().toString(36).slice(2, 10);
   const MEMORY = {
     'preferencies.md': '# Preferències\n\n- Respon en català.\n- Fes commits petits i explica’ls bé.\n',
-    'projectes/web-botiga.md': '# web-botiga\n\nBotiga en línia feta amb Astro. Els colors són a src/styles.css.\n',
+    'projectes/web-botiga.md': '# web-botiga\n\nBotiga en línia feta amb Astro. Els colors són a src/styles.css.\n- Es desplega fent push a main\n- Fa servir pnpm, no npm\n',
   };
+  // La memòria que aprèn sola: una contradicció per decidir i un fet après.
+  const LEARN = {
+    auto: true, reviewing: false, learning: 0,
+    pending: [{ id: 'c1', t: Date.now() - 3600000, file: 'projectes/web-botiga.md', title: 'Desplegament manual', old: 'Es desplega fent push a main', new: 'Es desplega a mà amb «vercel deploy --prod» (la integració de GitHub s’ha tret)' }],
+    log: [{ id: 'l1', t: Date.now() - 3600000, file: 'projectes/web-botiga.md', text: 'Fa servir pnpm, no npm' }],
+  };
+  const memLines = (f) => (MEMORY[f] || '').split('\n');
   const DIRS = { [ROOT]: ['web-botiga', 'api', 'notes'], [`${ROOT}/api`]: ['src', 'test'], [`${ROOT}/web-botiga`]: ['public', 'src'] };
 
   async function route(method, p, q, body) {
@@ -324,6 +331,7 @@
       if (/^\/api\/sessions\/[\w-]+\/git$/.test(p)) return { repo: false };
       if (p === '/api/projects') return [{ path: ROOT, name: 'projectes', root: true, git: false }, ...DIRS[ROOT].map((n) => ({ path: `${ROOT}/${n}`, name: n, root: false, git: n !== 'notes' }))];
       if (p === '/api/fs') { const d = (q.get('path') || ROOT).replace(/\/+$/, '') || ROOT; return { path: d, parent: d === '/Users/tu' ? null : d.replace(/\/[^/]+$/, '') || null, home: '/Users/tu', git: false, dirs: (DIRS[d] || []).map((n) => ({ name: n, path: `${d}/${n}`, hidden: false })) }; }
+      if (p === '/api/memory/learn') return LEARN;
       if (p === '/api/memory') return { dir: '~/.nio/memory', files: Object.entries(MEMORY).map(([path, c]) => ({ path, size: c.length, updated: Date.now() - 86400000 })) };
       if ((m = p.match(/^\/api\/memory\/f\/(.+)$/))) { const path = decodeURIComponent(m[1]); if (!(path in MEMORY)) throw err(404, 'Aquest fitxer no existeix'); return { path, content: MEMORY[path], updated: Date.now() - 86400000 }; }
       if (p === '/api/memory/search') { const t = (q.get('q') || '').toLowerCase(), r = []; for (const [path, c] of Object.entries(MEMORY)) c.split('\n').forEach((l, i) => l.toLowerCase().includes(t) && t && r.push({ path, line: i + 1, text: l })); return r; }
@@ -371,6 +379,17 @@
     }
     if (method === 'DELETE' && (m = p.match(/^\/api\/jobs\/([\w-]+)$/))) { const i = jobs.findIndex((x) => x.id === m[1]); if (i >= 0) jobs.splice(i, 1); out({ type: 'job', removed: m[1] }); return { ok: true }; }
     if (method === 'PUT' && p === '/api/control') { for (const k of ['navegador', 'escriptori']) if (typeof body[k] === 'boolean') caps[k].enabled = body[k]; return { ...caps, notes: [] }; }
+    if (p === '/api/memory/learn' && method === 'PUT') { LEARN.auto = !!body.auto; return LEARN; }
+    if (p === '/api/memory/review' && method === 'POST') { await sleep(1200); return { found: 0, pending: LEARN.pending }; }
+    if ((m = p.match(/^\/api\/memory\/pending\/([\w-]+)$/)) && method === 'POST') {
+      const c = LEARN.pending.find((x) => x.id === m[1]);
+      if (c && body.choice !== 'antic') { const ls = memLines(c.file); const i = ls.findIndex((l) => l.includes(c.old)); if (body.choice === 'nou' && i >= 0) ls[i] = `- ${c.new}`; else ls.push(`- ${c.new}`); MEMORY[c.file] = ls.join('\n'); }
+      LEARN.pending = LEARN.pending.filter((x) => x.id !== m[1]); return LEARN;
+    }
+    if ((m = p.match(/^\/api\/memory\/log\/([\w-]+)$/)) && method === 'DELETE') {
+      const e = LEARN.log.find((x) => x.id === m[1]); if (e) MEMORY[e.file] = memLines(e.file).filter((l) => !l.includes(e.text)).join('\n');
+      LEARN.log = LEARN.log.filter((x) => x.id !== m[1]); return { ok: true };
+    }
     if ((m = p.match(/^\/api\/memory\/f\/(.+)$/))) {
       if (method === 'PUT') { MEMORY[decodeURIComponent(m[1])] = String(body.content ?? ''); return { ok: true }; }
       if (method === 'DELETE') { delete MEMORY[decodeURIComponent(m[1])]; return { ok: true }; }

package/web/app/style.css

@@ -709,6 +709,15 @@ dialog.sheet.wiz.compact .sheet-in, .compact .wiz-body { flex: 0 1 auto; }
 .mem-list .card { color: var(--fg); }
 .mem-list .card b { color: var(--fg); }
 .section-title + .mem-list { margin-bottom: 8px; }
+.mem-learn { gap: 10px; margin-bottom: 20px; }
+.mem-conflict { display: grid; gap: 8px; color: var(--fg); cursor: default; }
+.mem-conflict .mem-old, .mem-conflict .mem-new { display: grid; gap: 2px; padding: 8px 10px; border-radius: 10px; background: var(--bg-2, rgba(127, 127, 127, .08)); }
+.mem-conflict .mem-old s { text-decoration-color: var(--fg-muted); }
+.mem-learned { color: var(--fg); cursor: default; align-items: flex-start; }
+.mem-auto { display: flex; gap: 12px; align-items: center; justify-content: space-between; flex-wrap: wrap; padding: 14px 16px; margin: 0 0 24px; }
+.mem-auto .check { align-items: flex-start; flex: 1 1 260px; flex-wrap: nowrap; }
+.mem-auto .check input { margin-top: 2px; flex: none; }
+.mem-auto .block { display: block; margin-top: 2px; }
 
 /* Capçalera d'una secció dins d'una pàgina */
 .sec-head { display: flex; flex-direction: column; align-items: flex-start; gap: 12px; margin: 36px 0 14px; }

package/web/sw.js

@@ -1,5 +1,5 @@
 // nio · service worker: obre l'app encara que no hi hagi connexió i mostra els avisos.
-const SHELL = 'nio-shell-v62';
+const SHELL = 'nio-shell-v63';
 const FILES = ['/app', '/app/style.css', '/app/notes.css', '/app/call.css', '/app/app.js', '/app/notes.js', '/app/notes-live.js', '/app/call.js', '/app/demo.js', '/app/android.js', '/bot.css', '/bot.js', '/board.css', '/board.js', '/favicon.svg', '/manifest.webmanifest'];
 
 self.addEventListener('install', (e) => {