nio-cat 0.9.14 → 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.14",
+  "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

@@ -5,6 +5,10 @@ const path = require('path');
 const { run, tryJson } = require('../proc');
 
 const HOOK = path.join(__dirname, '..', 'claude-hook.js');
+// L'ordre del hook la llança la shell de Claude Code (a Windows, Git Bash): el Node d'aquest mateix procés i
+// barres «/», que entenen totes les shells.
+const slash = (p) => (process.platform === 'win32' ? p.replace(/\\/g, '/') : p);
+const HOOK_CMD = `"${slash(process.execPath)}" "${slash(HOOK)}"`;
 
 module.exports = {
   id: 'claude',
@@ -21,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).
@@ -30,7 +36,7 @@ module.exports = {
     const env = {};
     const gate = (extra = {}) => {
       // Hook PreToolUse: envia al mòbil el que cal aprovar.
-      args.push('--settings', JSON.stringify({ hooks: { PreToolUse: [{ matcher: '*', hooks: [{ type: 'command', command: `node "${HOOK}"`, timeout: 900 }] }] } }));
+      args.push('--settings', JSON.stringify({ hooks: { PreToolUse: [{ matcher: '*', hooks: [{ type: 'command', command: HOOK_CMD, timeout: 900 }] }] } }));
       Object.assign(env, { NIO_HOOK_URL: ctx.hook.url, NIO_HOOK_KEY: ctx.hook.key, NIO_SESSION: session.id }, extra);
     };
     const control = cfg.control?.navegador || cfg.control?.escriptori;
@@ -47,7 +53,7 @@ module.exports = {
           PreToolUse: [
             {
               matcher: '*',
-              hooks: [{ type: 'command', command: `node "${HOOK}"`, timeout: 900 }],
+              hooks: [{ type: 'command', command: HOOK_CMD, timeout: 900 }],
             },
           ],
         },

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/control.js

@@ -10,7 +10,7 @@ const os = require('os');
 const path = require('path');
 const crypto = require('crypto');
 const { spawn } = require('child_process');
-const { which, childEnv } = require('./proc');
+const { which, childEnv, command, killTree } = require('./proc');
 const config = require('./config');
 const { HOME } = config;
 
@@ -61,11 +61,13 @@ function run(bin, args, timeout = 15000) {
       resolve({ ok, out, err: err || why || '', timedOut: why === 'temps' });
     };
     const timer = setTimeout(() => {
-      try { process.kill(-child.pid, 'SIGKILL'); } catch { try { child.kill('SIGKILL'); } catch { /* ja no hi és */ } }
+      if (process.platform === 'win32') killTree(child?.pid);
+      else try { process.kill(-child.pid, 'SIGKILL'); } catch { try { child.kill('SIGKILL'); } catch { /* ja no hi és */ } }
       finish(false, 'temps');
     }, timeout);
     try {
-      child = spawn(bin, args, { env: childEnv(), stdio: ['ignore', 'pipe', 'pipe'], detached: process.platform !== 'win32' });
+      const c = command(bin, args);
+      child = spawn(c.cmd, c.args, { env: childEnv(), stdio: ['ignore', 'pipe', 'pipe'], detached: process.platform !== 'win32', windowsHide: true, ...c.opts });
     } catch (e) { return finish(false, e.message); }
     child.stdout.on('data', (d) => { if (out.length < 8 << 20) out += d; });
     child.stderr.on('data', (d) => { if (err.length < 1 << 20) err += d; });

package/src/hub.js

@@ -194,7 +194,8 @@ class Hub extends EventEmitter {
   codexStatus(s, bp) {
     const { execFile } = require('child_process');
     const codex = s.agent === 'codex', name = byId[s.agent]?.name || s.agent;
-    execFile(bp, codex ? ['login', 'status'] : ['--version'], { timeout: 8000 }, (err, out, errOut) => {
+    const c = require('./proc').command(bp, codex ? ['login', 'status'] : ['--version']);
+    execFile(c.cmd, c.args, { timeout: 8000, windowsHide: true, ...c.opts }, (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 = [codex ? `**Compte:** ${login}` : `**Versió:** ${login}`, `**Model:** ${s.model || s.modelUsed || 'el de per defecte'}`, `**Carpeta:** \`${s.cwd}\``, `**Permisos:** ${s.mode}`, `**Conversa:** ${s.nativeId ? `continua la de ${name}` : 'encara no ha començat'}`];
       this.push(s, 'text', { text: lines.join('\n\n') });
@@ -334,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({});
@@ -122,10 +145,11 @@ function command() {
 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 sync = (args, o) => { const c = require('./proc').command(bin, args); return spawnSync(c.cmd, c.args, { windowsHide: true, ...o, ...c.opts }); };
+  if (!force && sync(['mcp', 'get', 'nio'], { encoding: 'utf8', timeout: 15000 }).status === 0) return 'ja hi era';
+  sync(['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 });
+  const r = sync(['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()}`;
 }
 

package/src/notes.js

@@ -8,7 +8,7 @@ const path = require('path');
 const crypto = require('crypto');
 const { spawn } = require('child_process');
 const { HOME } = require('./config');
-const { childEnv } = require('./proc');
+const { childEnv, command, killTree } = require('./proc');
 const voice = require('./voice');
 const ollama = require('./agents/ollama');
 
@@ -470,9 +470,10 @@ function parseJson(raw) {
 // ---------- 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'] });
+    const c = command(bin, args);
+    const p = spawn(c.cmd, c.args, { cwd, env: childEnv(), stdio: ['pipe', 'pipe', 'pipe'], windowsHide: true, ...c.opts });
     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);
+    const t = setTimeout(() => { if (process.platform === 'win32') killTree(p.pid); else 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}`)); });

package/src/proc.js

@@ -5,27 +5,28 @@ const os = require('os');
 const path = require('path');
 const { spawn, execFile } = require('child_process');
 
+const WIN = process.platform === 'win32';
 const EXTRA_DIRS = [
   path.join(os.homedir(), '.nio', 'bin'),
+  // Windows: npm -g, l'instal·lador natiu de Claude Code i winget.
+  ...(WIN ? [process.env.APPDATA && path.join(process.env.APPDATA, 'npm'), process.env.LOCALAPPDATA && path.join(process.env.LOCALAPPDATA, 'Microsoft', 'WinGet', 'Links'), process.env.ProgramFiles && path.join(process.env.ProgramFiles, 'nodejs')].filter(Boolean) : []),
   path.join(os.homedir(), '.local', 'bin'),
   path.join(os.homedir(), '.npm-global', 'bin'),
   path.join(os.homedir(), '.bun', 'bin'),
   path.join(os.homedir(), '.grok', 'bin'),
-  '/opt/homebrew/bin',
-  '/usr/local/bin',
-  '/usr/bin',
+  ...(WIN ? [] : ['/opt/homebrew/bin', '/usr/local/bin', '/usr/bin']),
 ];
 
 function searchPath() {
-  const parts = (process.env.PATH || '').split(path.delimiter).filter(Boolean);
-  for (const d of EXTRA_DIRS) if (!parts.includes(d)) parts.push(d);
+  const parts = (process.env.PATH || process.env.Path || '').split(path.delimiter).filter(Boolean);
+  for (const d of EXTRA_DIRS) if (!parts.some((x) => (WIN ? x.toLowerCase() === d.toLowerCase() : x === d))) parts.push(d);
   return parts;
 }
 
 function which(bin) {
   if (!bin) return null;
   if (bin.includes('/') || bin.includes('\\')) return fs.existsSync(bin) ? bin : null;
-  const exts = process.platform === 'win32' ? ['.exe', '.cmd', '.bat', ''] : [''];
+  const exts = WIN ? ['.exe', '.cmd', '.bat'] : [''];
   for (const dir of searchPath()) {
     for (const ext of exts) {
       const p = path.join(dir, bin + ext);
@@ -40,9 +41,44 @@ function which(bin) {
   return null;
 }
 
+// Windows: els CLI de npm (claude.cmd, codex.cmd…) són scripts .cmd, i Node no els executa sense una shell
+// (i passar-hi el text de l'usuari per cmd.exe seria perillós). Es llegeix l'script i s'executa directament
+// el que hi ha a dins: «node …\cli.js» o un .exe. Si no s'entén, cmd.exe amb els arguments escapats.
+const shimCache = new Map();
+function command(bin, args = []) {
+  if (!WIN || !/\.(cmd|bat)$/i.test(bin)) return { cmd: bin, args, opts: {} };
+  let target = shimCache.get(bin);
+  if (target === undefined) {
+    target = null;
+    try {
+      const txt = fs.readFileSync(bin, 'utf8');
+      // El primer «"%dp0%\…"» que existeixi, sense comptar el node.exe opcional de la mateixa carpeta.
+      for (const m of txt.matchAll(/"%~?dp0%?\\?([^"%]+?\.(?:js|cjs|mjs|exe))"/gi)) {
+        const p = path.join(path.dirname(bin), m[1]);
+        if (!/^node\.exe$/i.test(m[1]) && fs.existsSync(p)) { target = p; break; }
+      }
+    } catch {
+      /* no es pot llegir */
+    }
+    shimCache.set(bin, target);
+  }
+  if (target && /\.exe$/i.test(target)) return { cmd: target, args, opts: {} };
+  if (target) return { cmd: process.execPath, args: [target, ...args], opts: {} };
+  const line = [bin, ...args].map(cmdQuote).join(' ');
+  return { cmd: process.env.ComSpec || 'cmd.exe', args: ['/d', '/s', '/c', `"${line}"`], opts: { windowsVerbatimArguments: true } };
+}
+// Cometes per a cmd.exe: les de CreateProcess i, a sobre, ^ davant dels caràcters especials de cmd.
+function cmdQuote(a) {
+  let s = String(a);
+  if (s && !/[\s"^&|<>%!()]/.test(s)) return s;
+  s = `"${s.replace(/(\\*)"/g, '$1$1\\"').replace(/(\\+)$/, '$1$1')}"`;
+  return s.replace(/[\^&|<>%!()"]/g, '^$&');
+}
+
 function version(binPath, args = ['--version']) {
   return new Promise((resolve) => {
-    execFile(binPath, args, { timeout: 4000, env: childEnv() }, (err, stdout, stderr) => {
+    const c = command(binPath, args);
+    execFile(c.cmd, c.args, { timeout: 4000, env: childEnv(), windowsHide: true, ...c.opts }, (err, stdout, stderr) => {
       const out = String(stdout || stderr || '').trim().split('\n')[0];
       resolve(err && !out ? null : out.slice(0, 60));
     });
@@ -75,11 +111,14 @@ function run({ bin, args, cwd, env, stdin, onLine, onErr, onExit, tty }) {
       argv = ['-qfec', [bin, ...args].map(shQuote).join(' '), '/dev/null'];
     }
   }
-  const child = spawn(cmd, argv, {
+  const c = command(cmd, argv);
+  const child = spawn(c.cmd, c.args, {
     cwd,
     env: childEnv(env),
     stdio: ['pipe', 'pipe', 'pipe'],
-    detached: process.platform !== 'win32',
+    detached: !WIN,
+    windowsHide: true,
+    ...c.opts,
   });
   if (stdin != null) child.stdin.end(stdin);
   else child.stdin.end();
@@ -109,8 +148,8 @@ function run({ bin, args, cwd, env, stdin, onLine, onErr, onExit, tty }) {
     child,
     kill() {
       try {
-        if (process.platform !== 'win32') process.kill(-child.pid, 'SIGTERM');
-        else child.kill();
+        if (!WIN) process.kill(-child.pid, 'SIGTERM');
+        else killTree(child.pid);
       } catch {
         try {
           child.kill();
@@ -122,6 +161,16 @@ function run({ bin, args, cwd, env, stdin, onLine, onErr, onExit, tty }) {
   };
 }
 
+// Windows: atura el procés i tots els que ha obert (l'agent, les seves eines…).
+function killTree(pid) {
+  if (!pid) return;
+  try {
+    spawn('taskkill', ['/pid', String(pid), '/T', '/F'], { stdio: 'ignore', windowsHide: true }).on('error', () => {});
+  } catch {
+    /* ja ha acabat */
+  }
+}
+
 function shQuote(s) {
   return `'${String(s).replace(/'/g, `'\\''`)}'`;
 }
@@ -141,4 +190,4 @@ function tryJson(line) {
   }
 }
 
-module.exports = { which, version, run, childEnv, tryJson, stripAnsi, searchPath, shQuote };
+module.exports = { which, version, run, childEnv, tryJson, stripAnsi, searchPath, shQuote, command, cmdQuote, killTree };

package/src/service.js

@@ -1,5 +1,6 @@
 'use strict';
-// Servei del sistema perquè nio arrenqui sol amb l'ordinador (systemd a Linux, launchd a macOS).
+// Servei del sistema perquè nio arrenqui sol amb l'ordinador (systemd a Linux, launchd a macOS i, a Windows,
+// un script a la carpeta Inici que l'engega amagat en iniciar sessió i el torna a obrir si es tanca).
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
@@ -66,8 +67,37 @@ ${args}
 `;
 }
 
+// Windows: no cal ser administrador. L'script fa de supervisor: engega nio sense finestra, n'escriu la sortida
+// a ~/.nio/nio.log i, si es tanca, el torna a obrir al cap de 3 segons.
+function windowsStartup() {
+  return path.join(process.env.APPDATA || path.join(os.homedir(), 'AppData', 'Roaming'), 'Microsoft', 'Windows', 'Start Menu', 'Programs', 'Startup', 'nio.vbs');
+}
+function windowsVbs({ roots }) {
+  const qv = (s) => String(s).replace(/"/g, '""'); // dins d'una cadena de VBScript
+  const arg = (s) => `"${s}"`;
+  // cmd /s /c "…": treu les cometes de fora i executa la resta tal qual (amb la redirecció al registre).
+  const line = qv(`cmd /d /s /c "${[process.execPath, entry(), '--no-open', ...roots].map(arg).join(' ')} >> ${arg(path.join(HOME, 'nio.log'))} 2>&1"`);
+  return `' nio · s'engega en iniciar sessió (nio service uninstall per treure-ho)
+Set sh = CreateObject("WScript.Shell")
+Set env = sh.Environment("PROCESS")
+env("NO_COLOR") = "1"
+env("PATH") = "${qv(searchPath().join(';'))}"
+${process.env.NIO_HOME ? `env("NIO_HOME") = "${qv(process.env.NIO_HOME)}"
+` : ''}sh.CurrentDirectory = "${qv(roots[0] || os.homedir())}"
+Do
+  sh.Run "${line}", 0, True
+  WScript.Sleep 3000
+Loop
+`;
+}
+// Atura el supervisor i nio (els processos que en porten la ruta a la línia d'ordres).
+function windowsStop() {
+  const ps = `Get-CimInstance Win32_Process | Where-Object { ($_.Name -eq 'wscript.exe' -and $_.CommandLine -like '*nio.vbs*') -or ($_.Name -eq 'node.exe' -and $_.CommandLine -like '*${entry().replace(/'/g, "''")}*--no-open*') } | ForEach-Object { Stop-Process -Id $_.ProcessId -Force -ErrorAction SilentlyContinue }`;
+  sh('powershell', ['-NoProfile', '-NonInteractive', '-Command', ps]);
+}
+
 function sh(cmd, args) {
-  const r = spawnSync(cmd, args, { encoding: 'utf8' });
+  const r = spawnSync(cmd, args, { encoding: 'utf8', windowsHide: true });
   return { ok: r.status === 0, out: `${r.stdout || ''}${r.stderr || ''}`.trim() };
 }
 
@@ -85,7 +115,18 @@ function install({ roots, log = console.log }) {
     if (!r.ok) throw new Error(`launchctl no l’ha pogut carregar: ${r.out}`);
     return { file, logs: `tail -f ${path.join(HOME, 'nio.log')}` };
   }
-  if (process.platform !== 'linux') throw new Error('El servei automàtic només funciona a Linux (systemd) i macOS (launchd).');
+  if (process.platform === 'win32') {
+    const file = windowsStartup();
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.mkdirSync(HOME, { recursive: true });
+    windowsStop();
+    fs.writeFileSync(file, windowsVbs({ roots }));
+    const child = require('child_process').spawn('wscript.exe', ['//B', '//Nologo', file], { detached: true, stdio: 'ignore', windowsHide: true });
+    child.on('error', () => {});
+    child.unref();
+    return { file, logs: `Get-Content -Wait "${path.join(HOME, 'nio.log')}"` };
+  }
+  if (process.platform !== 'linux') throw new Error('El servei automàtic només funciona a Linux (systemd), macOS (launchd) i Windows.');
   if (!sh('systemctl', ['--version']).ok) throw new Error('Aquest sistema no té systemd.');
   const system = process.getuid && process.getuid() === 0;
   const file = system ? '/etc/systemd/system/nio.service' : path.join(os.homedir(), '.config', 'systemd', 'user', 'nio.service');
@@ -105,6 +146,12 @@ function install({ roots, log = console.log }) {
 }
 
 function uninstall() {
+  if (process.platform === 'win32') {
+    const file = windowsStartup();
+    windowsStop();
+    fs.rmSync(file, { force: true });
+    return file;
+  }
   if (process.platform === 'darwin') {
     const file = path.join(os.homedir(), 'Library', 'LaunchAgents', `${LABEL}.plist`);
     sh('launchctl', ['unload', '-w', file]);
@@ -120,4 +167,4 @@ function uninstall() {
   return file;
 }
 
-module.exports = { install, uninstall, systemdUnit, launchdPlist };
+module.exports = { install, uninstall, systemdUnit, launchdPlist, windowsVbs };

package/web/app/app.js

@@ -670,7 +670,12 @@ function render() {
 /* ---------- Ordinadors (llista, afegir i detall de l'actiu) */
 const deviceId = () => { let d = LS.get('nio.device', ''); if (!d) { d = Math.random().toString(36).slice(2, 12); LS.set('nio.device', d); } return d; };
 const isPhone = () => navigator.userAgentData?.mobile === true || /Android|iPhone|iPod|Mobile/i.test(navigator.userAgent) || (isTouch && matchMedia('(max-width: 1024px)').matches);
-const INSTALL_CMD = 'curl -fsSL https://www.nio.cat/install.sh | sh';
+const SH_CMD = 'curl -fsSL https://www.nio.cat/install.sh | sh', WIN_CMD = 'irm https://www.nio.cat/install.ps1 | iex';
+// En un PC amb Windows, l'ordre de PowerShell; a la resta (i al mòbil, que no sap quin ordinador tens), la de Mac i Linux.
+const isWindows = !isPhone() && (navigator.userAgentData?.platform === 'Windows' || /Windows/.test(navigator.userAgent));
+const INSTALL_CMD = isWindows ? WIN_CMD : SH_CMD;
+const OPEN_TERM = isWindows ? 'Obre PowerShell: prem la tecla Windows i escriu «PowerShell».' : 'Obre el Terminal. Al Mac, prem ⌘ Espai i escriu «Terminal».';
+const OTHER_OS = isWindows ? `Windows. A Mac o Linux: <span class="mono">${SH_CMD}</span>` : `Mac o Linux. A Windows, al PowerShell: <span class="mono">${WIN_CMD}</span>`;
 const cmdBox = (c) => `<div class="cmd big"><code>${esc(c)}</code><button class="btn sm" data-copy="${esc(c)}" type="button">${svg(ICON.copy)}Copia</button></div>`;
 // Estat de la resta d'ordinadors (el connectat ja té el seu flux en directe): una consulta lleugera.
 const reach = new Map();
@@ -805,9 +810,9 @@ function viewComputers() {
   if (!ms.length) {
     const phone = isPhone();
     const steps = phone
-      ? [['Enganxa-la a l’ordinador', 'Al Terminal. Instal·la nio i el deixa engegat, també quan reinicies.'], ['Escaneja el QR', 'Surt al navegador de l’ordinador quan acaba. També hi ha un codi.'], ['Dona feina a un agent', 'Tria l’agent i la carpeta, i mira com treballa des d’aquí.']]
-      : [['Obre el Terminal', 'Al Mac, ⌘ Espai i escriu «Terminal». A Linux, Ctrl Alt T.'], ['Enganxa l’ordre', 'Instal·la nio i el deixa engegat, també quan reinicies.'], ['Escaneja el QR', 'Aquesta web es connecta sola i et mostra el QR del mòbil.']];
-    return `${head}<div class="panel empty first-run">${bot('idle')}<h2>Connecta el teu primer ordinador</h2><p>${phone ? 'nio s’instal·la a l’ordinador amb una sola ordre. Copia-la i enganxa-la allà.' : 'Una sola ordre instal·la nio en aquest ordinador i ho deixa tot a punt.'}</p>${cmdBox(INSTALL_CMD)}<ol class="stepper">${steps.map(([t, d], i) => `<li><span class="n">${i + 1}</span><div><b>${t}</b><p>${d}</p></div></li>`).join('')}</ol><div class="row" style="justify-content:center"><button class="btn ink" data-act="add-computer" type="button">${svg(ICON.plus)}${phone ? 'Tinc un codi o un QR' : 'Afegeix ordinador'}</button><button class="btn" data-act="demo" type="button">Prova una demo</button></div><p class="muted small">Mac o Linux. Per provar-lo sense instal·lar res, <span class="mono">npx nio-cat</span>.</p></div>`;
+      ? [['Enganxa-la a l’ordinador', 'Al Terminal (a Windows, a PowerShell). Instal·la nio i el deixa engegat, també quan reinicies.'], ['Escaneja el QR', 'Surt al navegador de l’ordinador quan acaba. També hi ha un codi.'], ['Dona feina a un agent', 'Tria l’agent i la carpeta, i mira com treballa des d’aquí.']]
+      : [isWindows ? ['Obre PowerShell', 'Prem la tecla Windows i escriu «PowerShell».'] : ['Obre el Terminal', 'Al Mac, ⌘ Espai i escriu «Terminal». A Linux, Ctrl Alt T.'], ['Enganxa l’ordre', 'Instal·la nio i el deixa engegat, també quan reinicies.'], ['Escaneja el QR', 'Aquesta web es connecta sola i et mostra el QR del mòbil.']];
+    return `${head}<div class="panel empty first-run">${bot('idle')}<h2>Connecta el teu primer ordinador</h2><p>${phone ? 'nio s’instal·la a l’ordinador amb una sola ordre. Copia-la i enganxa-la allà.' : 'Una sola ordre instal·la nio en aquest ordinador i ho deixa tot a punt.'}</p>${cmdBox(INSTALL_CMD)}<ol class="stepper">${steps.map(([t, d], i) => `<li><span class="n">${i + 1}</span><div><b>${t}</b><p>${d}</p></div></li>`).join('')}</ol><div class="row" style="justify-content:center"><button class="btn ink" data-act="add-computer" type="button">${svg(ICON.plus)}${phone ? 'Tinc un codi o un QR' : 'Afegeix ordinador'}</button><button class="btn" data-act="demo" type="button">Prova una demo</button></div><p class="muted small">${OTHER_OS}. Per provar-lo sense instal·lar res, <span class="mono">npx nio-cat</span>.</p></div>`;
   }
   const detail = m && state.connected ? `<h2 class="sec">${esc(m.name)}</h2>
   <div class="grid2 one">
@@ -894,7 +899,7 @@ function addComputerSheet(tab, opts = {}) {
       const saved = d && store.machines.findIndex((x) => x.id === d.id);
       if (d && saved >= 0) set('saved', `${intro('Aquest ordinador ja és a la llista', 'El tens connectat com a «' + esc(d.name) + '».')}<div class="row"><button class="btn ink" type="button" data-open-saved="${saved}">Obre sessions</button></div>`);
       else if (d) set('found', `${intro('nio ja funciona en aquest ordinador', 'Aquest navegador encara no hi té accés. Escriu això al Terminal i s’obrirà el panell ja connectat:')}${cmdBox('nio pair')}`);
-      else set('none', `${intro('Instal·la nio en aquest ordinador', 'Una sola ordre ho deixa tot a punt i engegat, també quan reinicies.')}${todo(['Obre el Terminal. Al Mac, prem ⌘ Espai i escriu «Terminal».', `Enganxa aquesta ordre i prem Retorn:${cmdBox(INSTALL_CMD)}`, 'Quan acabi, aquesta pàgina es connectarà sola.'])}${live('Esperant nio…')}<p class="hint">Mac o Linux. Si ja el tens i està aturat, escriu <span class="mono">nio</span> al Terminal.</p>${store.machines.length ? '' : '<div class="or"><span>o</span></div><button class="btn block" type="button" data-close data-act="demo">Prova una demo, sense instal·lar res</button>'}`);
+      else set('none', `${intro('Instal·la nio en aquest ordinador', 'Una sola ordre ho deixa tot a punt i engegat, també quan reinicies.')}${todo([OPEN_TERM, `Enganxa aquesta ordre i prem Retorn:${cmdBox(INSTALL_CMD)}`, 'Quan acabi, aquesta pàgina es connectarà sola.'])}${live('Esperant nio…')}<p class="hint">${OTHER_OS}. Si ja el tens i està aturat, escriu <span class="mono">nio</span> al ${isWindows ? 'PowerShell' : 'Terminal'}.</p>${store.machines.length ? '' : '<div class="or"><span>o</span></div><button class="btn block" type="button" data-close data-act="demo">Prova una demo, sense instal·lar res</button>'}`);
       if (saved < 0 || !d) poll = setTimeout(local, 3000);
     };
     const runSsh = async (target) => {
@@ -1137,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>`;
@@ -1148,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();
 }
@@ -1174,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();
@@ -1530,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`);
@@ -2859,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/index.html

@@ -68,6 +68,8 @@ h1 { font-size: clamp(38px, 6.4vw, 68px); font-weight: 500; line-height: 1.04; l
 .install code { background: none; border-radius: 0; flex: 1; min-width: 0; overflow-x: auto; white-space: nowrap; padding: 9px 0; font: 500 15.5px ui-monospace, "SF Mono", Menlo, monospace; scrollbar-width: none; }
 .install code::-webkit-scrollbar { display: none; }
 .hero .alt { margin-top: 14px; font-size: 15px; color: var(--fg-muted); }
+.hero .os-sw { border: 0; padding: 0; background: none; font: inherit; color: inherit; text-decoration: underline; text-underline-offset: 3px; cursor: pointer; }
+.hero .os-sw:hover { color: var(--fg); }
 .copy { flex: none; display: inline-grid; place-items: center; width: 42px; height: 42px; border: 0; border-radius: 11px; background: rgba(255,255,255,.1); color: inherit; cursor: pointer; transition: background-color .2s, transform .12s; }
 .copy:hover { background: rgba(255,255,255,.2); }
 .copy:active { transform: scale(.95); }
@@ -203,7 +205,7 @@ main { padding-bottom: 8px; }
     <h1>Els teus agents, a les teves màquines, des del mòbil.</h1>
     <p class="lead">nio és un comandament per a Claude Code, Codex i altres agents. Treballen als teus ordinadors, amb els teus comptes i les teves claus. Tu els dones feina des del mòbil, els segueixes en directe i aproves el que és arriscat. Personal i gratuït.</p>
     <div class="install"><code id="cmd">curl -fsSL https://www.nio.cat/install.sh | sh</code><button class="copy" type="button" data-copy="curl -fsSL https://www.nio.cat/install.sh | sh" aria-label="Copia l’ordre"><svg class="ic" viewBox="0 0 24 24" aria-hidden="true"><rect x="8" y="8" width="12" height="12" rx="2"/><path d="M16 8V5a1 1 0 0 0-1-1H5a1 1 0 0 0-1 1v10a1 1 0 0 0 1 1h3"/></svg><svg class="ok" viewBox="0 0 24 24" aria-hidden="true"><path d="M5 12.5l4.5 4.5L19 7.5"/></svg></button></div>
-    <p class="alt"><span>Linux o Mac.</span> <span>Per provar-ho sense instal·lar: <code>npx nio-cat</code></span></p>
+    <p class="alt"><span><span id="osTxt">Linux o Mac.</span> <button class="os-sw" id="osSw" type="button">Tens Windows?</button></span> <span>Per provar-ho sense instal·lar: <code>npx nio-cat</code></span></p>
   </div>
 
   <section aria-labelledby="com">
@@ -255,6 +257,20 @@ main { padding-bottom: 8px; }
 </footer>
 <script src="/bot.js" defer></script>
 <script>
+// A Windows, l'ordre de PowerShell. Es pot canviar a mà (per instal·lar-lo en un altre ordinador).
+(() => {
+  const CMD = { unix: 'curl -fsSL https://www.nio.cat/install.sh | sh', win: 'irm https://www.nio.cat/install.ps1 | iex' };
+  const code = document.getElementById('cmd'), copy = code.nextElementSibling, txt = document.getElementById('osTxt'), sw = document.getElementById('osSw');
+  const set = (os) => {
+    code.textContent = CMD[os]; copy.dataset.copy = CMD[os]; sw.dataset.os = os;
+    txt.textContent = os === 'win' ? 'Windows, al PowerShell.' : 'Linux o Mac.';
+    sw.textContent = os === 'win' ? 'Tens Mac o Linux?' : 'Tens Windows?';
+  };
+  sw.onclick = () => set(sw.dataset.os === 'win' ? 'unix' : 'win');
+  set(navigator.userAgentData?.platform === 'Windows' || /Windows/.test(navigator.userAgent) ? 'win' : 'unix');
+})();
+</script>
+<script>
 document.addEventListener('click', async (e) => {
   const b = e.target.closest('[data-copy]'); if (!b) return;
   try { await navigator.clipboard.writeText(b.dataset.copy); }

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-v61';
+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) => {