@jossuealcala/madre 0.2.3 → 0.3.1

package/src/server.mjs

@@ -12,6 +12,10 @@ import { createEmbedder } from './embeddings.mjs';
 import { memoryServerFor } from './memory-tools.mjs';
 import { MotherChannel, CODE000_STRIKES } from './mother.mjs';
 import { ErrorSentinel } from './sentinel-errors.mjs';
+import { probeOllama, ollamaEmbedder, ollamaInvoker, pullModel } from './ollama.mjs';
+import { moduleById, describeModules, findModuleRoute } from './modules/index.mjs';
+import { madreAgent, madreInvoker, MADRE_AGENT_ID, MADRE_ADAPTER } from './adapters/madre.mjs';
+import { exportDataset, readiness as datasetReadiness } from './dataset.mjs';
 
 const PACKAGE = JSON.parse(await readFile(new URL('../package.json', import.meta.url), 'utf8').catch(() => '{}'));
 let crashHandlersInstalled = false;
@@ -35,9 +39,12 @@ import { QuotaMonitor } from './quota-monitor.mjs';
 import { defaultQuotaSources } from './quota-sources.mjs';
 import { Room } from './room.mjs';
 import { applyConfigToEnv, loadConfig } from './config.mjs';
-import { extensionById, listExtensions, runInstaller } from './extensions.mjs';
+import { extensionById, runInstaller } from './extensions.mjs';
 import { loginPlanFor, probeAll } from './auth-probe.mjs';
 import { loadConfig as readConfig, updateConfig } from './config.mjs';
+import { Privacy, normalizeTerms, privacySettings } from './privacy.mjs';
+import { checkForUpdate, detectInstall, updateCommand, releaseUrl } from './updates.mjs';
+import { totalmem } from 'node:os';
 import { discoverModels } from './models.mjs';
 import { setImageModule } from './capabilities.mjs';
 import { resolveGeminiKey } from './image-studio.mjs';
@@ -111,12 +118,14 @@ export async function createPulseServer({
   imageKey = resolveGeminiKey,
   // The sentinel's outbound channel; tests hand in a fake.
   reportFetch = globalThis.fetch,
+  // Ollama detection; tests hand in a fake probe. PULSE_OLLAMA=0 leaves Ollama alone entirely.
+  ollamaProbe = process.env.PULSE_OLLAMA === '0' ? async () => ({ running: false, host: null, models: [], embedModel: null, chatModel: null, disabled: true }) : probeOllama,
 }) {
   const root = stateRoot ?? process.env.PULSE_HOME ?? join(homedir(), '.pulse');
   // ~/.pulse/config.json fills in whatever the environment did not set.
   applyConfigToEnv(await loadConfig(root));
-  // RIPLEY renders HTML in the viewer only while the human has it switched on.
-  let ripleyEnabled = Boolean((await readConfig(root)).modules?.ripley?.enabled);
+  // RIPLEY renders HTML in the viewer only while the human has it switched on; read live, the switch is the module's.
+  const ripleyOn = async () => Boolean((await readConfig(root)).modules?.ripley?.enabled);
   agentTimeouts ??= agentTimeoutsFromEnv();
   const agents = providedAgents ?? await detectAgents();
   const canonicalProjectRoot = await realpath(projectRoot).catch(() => resolve(projectRoot));
@@ -125,25 +134,93 @@ export async function createPulseServer({
   const historicalEvents = await store.readAll();
   // The room's memory: derived from the ledger, rebuilt if missing or stale,
   // and never a reason for the room not to open.
-  const memory = await new RoomMemory(join(roomDir, 'memory.sqlite')).initialize(store)
+  // Release channel: one registry read a day, cached for every room on this machine. On by
+  // default; PULSE_UPDATE_CHECK=0 or the switch in MU/TH/UR turns it off. Never self-updates.
+  const updatesEnabled = () => (process.env.PULSE_UPDATE_CHECK !== undefined ? process.env.PULSE_UPDATE_CHECK !== '0' : updatesConfig.check !== false);
+  let updatesConfig = { ...((await readConfig(root)).updates ?? {}) };
+  const install = detectInstall({ projectRoot: canonicalProjectRoot });
+  async function versionView({ force = false } = {}) {
+    const check = await checkForUpdate({ name: PACKAGE.name, current: PACKAGE.version, cacheFile: join(root, 'updates.json'), fetchImpl: reportFetch, enabled: updatesEnabled(), force });
+    return { ...check, name: PACKAGE.name, install, command: updateCommand(install, PACKAGE.name, check.latest ?? 'latest'), release: check.latest ? releaseUrl(PACKAGE.repository, check.latest) : null, envWins: process.env.PULSE_UPDATE_CHECK !== undefined };
+  }
+  // Privacy: the terms that never travel through this room, from config.json and the environment.
+  // config.json is shared by every room on this machine, so the list is re-read before each
+  // human message and whenever MU/TH/UR looks: a term named in one room guards them all.
+  const privacy = new Privacy(privacySettings(await readConfig(root)));
+  const refreshPrivacy = async () => { const { terms, marker } = privacySettings(await readConfig(root)); privacy.set(terms, marker); return privacy; };
+  const memory = await new RoomMemory(join(roomDir, 'memory.sqlite')).attachPrivacy(privacy).initialize(store)
     .catch((error) => { console.error(`MADRE memory unavailable, turns get the recent window only: ${error.message}`); return null; });
   // Meaning-aware recall through the user's own Gemini key, when there is one;
   // and the memory as MCP tools for every agent's turn.
-  if (memory) {
-    const key = process.env.PULSE_EMBED === '0' ? null : await imageKey().catch(() => null);
-    memory.attachEmbedder(createEmbedder({ key }));
+  // Ollama, when it is there: local embeddings and a local archivist. Probed at
+  // start and again from MODULES; wired live, no restart.
+  let ollama = { running: false, host: null, models: [], embedModel: null, chatModel: null };
+  const ollamaSettings = async () => ({ enabled: true, embeddings: true, archivist: true, agent: true, ...((await readConfig(root)).modules?.ollama ?? {}) });
+  // What the TRAIN card needs: where the recipe ships, the room, the model name @madre will pick up, a base that fits this machine.
+  function trainingInfo() {
+    const slug = basename(canonicalProjectRoot).toLowerCase().replace(/[^a-z0-9]+/g, '-');
+    const gb = Math.round(totalmem() / 1024 ** 3);
+    return { roomDir, recipeDir: fileURLToPath(new URL('../docs/training/', import.meta.url)), modelName: `madre-${slug}`, baseModel: gb >= 32 ? 'Qwen/Qwen2.5-3B-Instruct' : 'Qwen/Qwen2.5-1.5B-Instruct', memoryGb: gb };
+  }
+  async function wireOllama({ probe: doProbe = true } = {}) {
+    if (doProbe) ollama = await ollamaProbe();
+    // A model trained on this room (docs/training) is named madre-<project>: @madre uses it when it exists.
+    const slug = basename(canonicalProjectRoot).toLowerCase().replace(/[^a-z0-9]+/g, '-');
+    const trained = (ollama.models ?? []).map((model) => model.name).find((name) => name.startsWith(`madre-${slug}`)) ?? null;
+    ollama = { ...ollama, madreModel: trained };
+    const settings = await ollamaSettings();
+    const useEmbeddings = ollama.running && settings.enabled && settings.embeddings && ollama.embedModel;
+    const useArchivist = ollama.running && settings.enabled && settings.archivist && ollama.chatModel;
+    if (memory) {
+      const key = process.env.PULSE_EMBED === '0' ? null : await imageKey().catch(() => null);
+      const embedder = createEmbedder({ key, env: embedEnvFor(await memoryConfig()), ollama: useEmbeddings ? ollama : null, ollamaEmbedder });
+      if (room) room.setEmbedder(embedder); else memory.attachEmbedder(embedder);
+    }
+    if (room) room.setInvoker('ollama', useArchivist ? ollamaInvoker({ host: ollama.host, model: ollama.chatModel }) : null);
+    // @madre: the fifth agent, present whenever Ollama has a chat model and the human left it on.
+    const fifth = madreAgent({ ...ollama, chatModel: ollama.madreModel ?? ollama.chatModel }, { enabled: settings.enabled && settings.agent !== false });
+    const index = agents.findIndex((agent) => agent.id === MADRE_AGENT_ID);
+    let changed = false;
+    if (fifth.ready && index < 0) { agents.push(fifth); changed = true; }
+    else if (fifth.ready && (agents[index].version !== fifth.version)) { Object.assign(agents[index], fifth); changed = true; }
+    else if (!fifth.ready && index >= 0) { agents.splice(index, 1); changed = true; }
+    if (room) {
+      room.setInvoker(MADRE_ADAPTER, fifth.ready ? madreInvoker({ memory, ollama: () => ({ ...ollama, chatModel: ollama.madreModel ?? ollama.chatModel }), fetchImpl: reportFetch }) : null);
+      if (changed) await room.record('agents.updated', { agents: agents.map((agent) => ({ id: agent.id, label: agent.label, detected: agent.detected, ready: agent.ready, version: agent.version, local: Boolean(agent.local) })), removed: fifth.ready ? [] : [MADRE_AGENT_ID], reason: fifth.ready ? `@madre is in the room · ${fifth.version}` : '@madre left the room: Ollama has no chat model running' });
+    }
+    return { ...ollama, settings, embeddings: Boolean(useEmbeddings), archivist: Boolean(useArchivist), agent: fifth.ready };
   }
+  // Memory settings the human keeps in config.json (MU/TH/UR → MEMORY); environment still wins at launch.
+  const memoryConfig = async () => ({ archivist: 'auto', archivists: null, every: 10, idleMinutes: 10, embedProvider: 'auto', recallShare: 0.3, ...((await readConfig(root)).memory ?? {}) });
+  const embedEnvFor = (cfg) => {
+    const view = { ...process.env };
+    if (!process.env.PULSE_EMBED_PROVIDER && !process.env.PULSE_EMBED) {
+      if (cfg.embedProvider === 'off') view.PULSE_EMBED = '0'; else if (cfg.embedProvider && cfg.embedProvider !== 'auto') view.PULSE_EMBED_PROVIDER = cfg.embedProvider;
+    }
+    return view;
+  };
+  let room = null;
+  await wireOllama();
   const memoryServer = memory ? memoryServerFor({ dbFile: memory.file, projectRoot: canonicalProjectRoot }) : null;
   // MOTHER's channel to the crew: her seal's fingerprint lives in the memory
   // file, so a deleted or edited .pulse/mother.env is noticed.
   const mother = new MotherChannel(join(canonicalProjectRoot, '.pulse', 'mother.env'), { meta: memory ? { get: (key) => memory.metaGet(key), set: (key, value) => memory.metaSet(key, value) } : null });
   const motherOutcome = await mother.load().catch((error) => { console.error(`MADRE could not open MOTHER's channel: ${error.message}`); return null; });
-  const room = new Room({
+  const startupMemory = await memoryConfig();
+  room = new Room({
     store,
     agents,
     projectRoot,
+    privacy,
     softTokenBudget,
     contextMaxChars,
+    recallShare: Number(process.env.PULSE_RECALL_SHARE ?? startupMemory.recallShare),
+    distill: {
+      every: Number(process.env.PULSE_DISTILL_EVERY ?? startupMemory.every),
+      idleMs: Number(process.env.PULSE_DISTILL_IDLE_MS ?? startupMemory.idleMinutes * 60000),
+      agent: process.env.PULSE_DISTILL_AGENT ?? (startupMemory.archivist && startupMemory.archivist !== 'auto' ? startupMemory.archivist : null),
+      allowed: Array.isArray(startupMemory.archivists) && startupMemory.archivists.length ? startupMemory.archivists : null,
+    },
     memory,
     memoryServer,
     mother: motherOutcome ? mother : null,
@@ -154,6 +231,7 @@ export async function createPulseServer({
     delegation,
     maxPlanSteps,
   });
+  await wireOllama({ probe: false });
   const embedKick = memory?.embedder ? setTimeout(() => void room.embedNow(), 2000) : null;
   embedKick?.unref?.();
   if (motherOutcome === 'deleted' || motherOutcome === 'altered') setTimeout(() => void room.motherTampered(motherOutcome).catch(() => {}), 500).unref?.();
@@ -181,6 +259,21 @@ export async function createPulseServer({
       geminiIdleMs: Number(process.env.PULSE_GEMINI_IDLE_MS ?? 90000),
       geminiRetries: Number(process.env.PULSE_GEMINI_RETRIES ?? 1),
       capabilities: room.capabilities(),
+      memory: memorySettingsView(),
+      updates: { check: updatesEnabled(), envWins: process.env.PULSE_UPDATE_CHECK !== undefined },
+      privacy: { terms: privacy.terms, marker: privacy.marker, envWins: privacySettings({}, process.env).envWins },
+    };
+  }
+  // What MU/TH/UR shows under MEMORY: the live values, who could distil, and what embeds today.
+  function memorySettingsView() {
+    const distill = room.distillSettings();
+    const candidates = [...(distill.ollama ? [{ id: 'ollama', label: `Ollama · ${ollama.chatModel ?? 'local'}`, local: true }] : []), ...agents.filter((agent) => agent.detected && !agent.local).map((agent) => ({ id: agent.id, label: agent.label, local: false }))];
+    return {
+      enabled: distill.enabled, every: distill.every, idleMinutes: Math.round(distill.idleMs / 60000), archivist: distill.agent ?? 'auto', archivists: distill.allowed, recallShare: distill.recallShare,
+      candidates, embedder: memory?.embedder?.model ?? null, embedProvider: process.env.PULSE_EMBED === '0' ? 'off' : (process.env.PULSE_EMBED_PROVIDER ?? null),
+      ollama: { running: ollama.running, embedModel: ollama.embedModel, chatModel: ollama.chatModel },
+      stats: room.memoryStats() ? { entries: room.memoryStats().entries, memories: room.memoryStats().memories, pending: room.memoryStats().pending } : null,
+      envWins: Boolean(process.env.PULSE_DISTILL_EVERY || process.env.PULSE_DISTILL_AGENT || process.env.PULSE_RECALL_SHARE || process.env.PULSE_EMBED_PROVIDER || process.env.PULSE_EMBED),
     };
   }
   async function applySettings(patch) {
@@ -208,6 +301,21 @@ export async function createPulseServer({
       if (Number(patch.room.maxPlanSteps) > 0) { config.room.maxPlanSteps = Number(patch.room.maxPlanSteps); live.maxPlanSteps = Number(patch.room.maxPlanSteps); }
       if (Number(patch.room.softTokenBudget) > 0) { config.room.softTokenBudget = Number(patch.room.softTokenBudget); live.softTokenBudget = Number(patch.room.softTokenBudget); }
     }
+    if (patch.memory && typeof patch.memory === 'object') {
+      const current = await memoryConfig();
+      const next = { ...current };
+      const m = patch.memory;
+      if (Number(m.every) >= 1) next.every = Math.trunc(Number(m.every));
+      if (Number(m.idleMinutes) >= 1) next.idleMinutes = Math.trunc(Number(m.idleMinutes));
+      if (typeof m.archivist === 'string') next.archivist = m.archivist === 'auto' ? 'auto' : m.archivist;
+      if (Array.isArray(m.archivists)) next.archivists = m.archivists.length ? m.archivists.map(String) : null;
+      if (['auto', 'ollama', 'gemini', 'off'].includes(m.embedProvider)) next.embedProvider = m.embedProvider;
+      if (Number.isFinite(Number(m.recallShare))) next.recallShare = Math.min(0.6, Math.max(0, Number(m.recallShare)));
+      if (typeof m.enabled === 'boolean') next.enabled = m.enabled;
+      config.memory = next;
+      room.configureDistill({ every: next.every, idleMs: next.idleMinutes * 60000, agent: next.archivist === 'auto' ? null : next.archivist, allowed: next.archivists, recallShare: next.recallShare, ...(typeof next.enabled === 'boolean' ? { enabled: next.enabled } : {}) });
+      live.memory = true;
+    }
     if (patch.scopes && typeof patch.scopes === 'object') {
       const current = (await readConfig(root)).scopes ?? {};
       config.scopes = { ...current };
@@ -226,6 +334,7 @@ export async function createPulseServer({
     }
     room.configure(live);
     await updateConfig(root, config);
+    if (live.memory) await wireOllama({ probe: false });
     await room.record('room.settings', { changed: Object.keys(config), settings: effectiveSettings() });
     return effectiveSettings();
   }
@@ -369,38 +478,52 @@ export async function createPulseServer({
   poller.unref();
 
   let installing = null;
-  async function installExtension(id, { confirm } = {}) {
+  // The context a module works in: the project, its settings, the room, and what this server offers.
+  async function moduleContext() {
+    const config = await readConfig(root);
+    return {
+      projectRoot: canonicalProjectRoot, stateRoot: root, config, env: process.env, agents, room,
+      readConfig: () => readConfig(root),
+      updateConfig: (patch) => updateConfig(root, patch),
+      record: (type, payload) => room.record(type, payload),
+      services: {
+        imageKey,
+        setImageModule,
+        ollama: {
+          state: () => ollama,
+          wire: (options) => wireOllama(options),
+          // Pulls stream into the room like a module install; one at a time.
+          pull: async (model) => {
+            if (installing) return { ok: false, error: `Another install is running (${installing}).` };
+            installing = 'ollama';
+            await room.record('extension.install.started', { id: 'ollama', name: 'OLLAMA', command: `ollama pull ${model}`, platforms: [], alreadyInstalled: false });
+            void (async () => {
+              let pending = [];
+              let flushTimer = null;
+              const flush = async () => { flushTimer = null; if (!pending.length) return; const batch = pending; pending = []; await room.record('extension.install.output', { id: 'ollama', lines: batch }); };
+              try {
+                await pullModel({ host: ollama.host, model, fetchImpl: reportFetch, onLine: (line) => { pending.push(line); if (!flushTimer) flushTimer = setTimeout(() => void flush(), 400); } });
+                await flush();
+                const status = await wireOllama();
+                await room.record('extension.install.finished', { id: 'ollama', name: 'OLLAMA', ok: true, installed: true, detail: `pulled ${model}`, ollama: status });
+              } catch (error) {
+                await flush();
+                await room.record('extension.install.finished', { id: 'ollama', name: 'OLLAMA', ok: false, installed: false, detail: error.message });
+              } finally { installing = null; }
+            })();
+            return { ok: true };
+          },
+        },
+      },
+    };
+  }
+
+  async function installExtension(id, payload = {}) {
+    const { confirm } = payload;
     const extension = extensionById(id);
     if (!extension) return { status: 404, body: { error: `Unknown module: ${id}.` } };
-    if (extension.id === 'ripley') {
-      const current = await readConfig(root);
-      const enabled = !Boolean(current.modules?.ripley?.enabled);
-      await updateConfig(root, { modules: { ...current.modules, ripley: { enabled } } });
-      ripleyEnabled = enabled;
-      await room.record('extension.toggled', { id, name: extension.name, enabled });
-      return { status: 200, body: { enabled } };
-    }
-    if (extension.id === 'ashcode') {
-      const current = await readConfig(root);
-      const enabled = !Boolean(current.modules?.ashCode?.enabled);
-      if (enabled && confirm !== true) return { status: 400, body: { error: 'AshCode is beta and can change meaning. Send { "confirm": true } to enable it.' } };
-      await updateConfig(root, { modules: { ...current.modules, ashCode: { enabled } } });
-      room.setAshCode(enabled);
-      await room.record('extension.toggled', { id, name: extension.name, enabled, beta: true });
-      return { status: 200, body: { enabled, beta: true, warning: 'AshCode beta may alter meaning; review the original. Character reduction is not verified token savings.' } };
-    }
-    if (extension.kind === 'builtin') {
-      // Image Studio: a switch in config.json, nothing written to the project.
-      const current = await readConfig(root);
-      const enabled = !(current.modules?.imageStudio?.enabled);
-      const key = await imageKey();
-      if (enabled && !key) return { status: 412, body: { error: 'No Gemini API key found. Sign in with the Gemini CLI (/auth → API key) or set GEMINI_API_KEY, then enable Image Studio.' } };
-      const model = typeof arguments[1]?.model === 'string' && arguments[1].model ? arguments[1].model : (current.modules?.imageStudio?.model ?? extension.models[0]);
-      await updateConfig(root, { modules: { ...current.modules, imageStudio: { enabled, model } } });
-      setImageModule({ enabled, model });
-      await room.record('extension.toggled', { id, name: extension.name, enabled, model });
-      return { status: 200, body: { enabled, model, capabilities: room.capabilities() } };
-    }
+    // Built-ins are switches the module itself defines.
+    if (extension.toggle) return extension.toggle(await moduleContext(), payload);
     if (confirm !== true) return { status: 400, body: { error: 'Installing a module writes into the project; send { "confirm": true } to proceed.' } };
     if (installing) return { status: 409, body: { error: `Another install is running (${installing}).` } };
     const preflight = extension.preflight ? await extension.preflight(canonicalProjectRoot) : { ok: true, problems: [] };
@@ -474,7 +597,7 @@ export async function createPulseServer({
           projectRoot,
           agents,
           ashCode: { enabled: room.ashCodeEnabled() },
-          ripley: { enabled: ripleyEnabled },
+          ripley: { enabled: await ripleyOn() },
           softTokenBudget,
           timeouts: Object.fromEntries(agents.map((agent) => [agent.id, room.timeoutFor(agent.id)])),
           delegation: { enabled: room.settings().delegation, maxPlanSteps: room.settings().maxPlanSteps },
@@ -544,7 +667,7 @@ export async function createPulseServer({
       // resolve to the same route.
       const previewMatch = request.method === 'GET' && url.pathname.match(/^\/preview\/(project|attachments)\/(.*)$/);
       if (previewMatch) {
-        if (!ripleyEnabled) return sendJson(response, 412, { error: 'RIPLEY is off. Enable it in MODULES to render files.' });
+        if (!(await ripleyOn())) return sendJson(response, 412, { error: 'RIPLEY is off. Enable it in MODULES to render files.' });
         const which = previewMatch[1] === 'attachments' ? attachmentsRoot : canonicalProjectRoot;
         const relative = decodeURIComponent(previewMatch[2]);
         const file = await readServable(which, relative);
@@ -578,6 +701,7 @@ export async function createPulseServer({
         return sendJson(response, 201, { attachment: { id: record.id, name: record.name, fileName: record.fileName, size: record.size, contentType: record.contentType, url: `/api/files?root=attachments&path=${encodeURIComponent(record.fileName)}` } });
       }
       if (request.method === 'GET' && url.pathname === '/api/settings') {
+        await refreshPrivacy();
         return sendJson(response, 200, { settings: effectiveSettings(), config: await readConfig(root), sessions, sessionsAt, loggingIn, agents: agents.map((agent) => ({ ...agent, login: loginPlanFor(agent) })) });
       }
       if (request.method === 'POST' && url.pathname === '/api/settings') {
@@ -602,6 +726,69 @@ export async function createPulseServer({
         const outcome = await sentinel.send(sentinelMatch[1]);
         return sendJson(response, outcome.ok ? 200 : (outcome.status === 404 || outcome.status === 412 ? outcome.status : 502), outcome);
       }
+      // Routes a module serves, before MADRE's own: the module answers with { status, body }.
+      const moduleRoute = findModuleRoute(request.method, url.pathname);
+      if (moduleRoute) {
+        const payload = request.method === 'POST' ? await body(request).catch(() => ({})) : {};
+        const result = await moduleRoute.route.handler(await moduleContext(), { request, url, params: moduleRoute.params, payload });
+        return sendJson(response, result.status ?? 200, result.body ?? {});
+      }
+      // The dataset behind MADRE AI: exported on demand next to the ledger.
+      if (url.pathname === '/api/dataset' && (request.method === 'GET' || request.method === 'POST')) {
+        const dir = join(roomDir, 'dataset');
+        const notes = memory ? memory.memories({ limit: 5000 }) : [];
+        if (request.method === 'GET') {
+          const manifest = await readFile(join(dir, 'manifest.json'), 'utf8').then(JSON.parse).catch(() => null);
+          return sendJson(response, 200, { dataset: manifest, dir, trained: ollama.madreModel ?? null, readiness: datasetReadiness(await store.readAll(), notes), training: trainingInfo() });
+        }
+        const events = await store.readAll();
+        const result = await exportDataset({ events, notes, dir, project: basename(canonicalProjectRoot), home: homedir(), privacy });
+        await room.record('dataset.exported', { pairs: result.pairs, turns: result.turns, notes: result.notes, train: result.train, valid: result.valid, dir });
+        return sendJson(response, 200, { dataset: result, dir, trained: ollama.madreModel ?? null, readiness: datasetReadiness(events, notes), training: trainingInfo() });
+      }
+      // PRIVACY: the terms live in config.json only; the ledger records counts, never words.
+      if (request.method === 'GET' && url.pathname === '/api/privacy') {
+        await refreshPrivacy();
+        return sendJson(response, 200, { terms: privacy.terms, marker: privacy.marker, exposure: room.privacyExposure(await store.readAll()) });
+      }
+      if (request.method === 'POST' && url.pathname === '/api/privacy') {
+        const patch = await body(request).catch(() => ({}));
+        const current = (await readConfig(root)).privacy ?? {};
+        const next = { ...current };
+        if ('terms' in patch) next.terms = normalizeTerms(patch.terms);
+        if (typeof patch.marker === 'string' && patch.marker.trim()) next.marker = patch.marker.trim().slice(0, 40);
+        await updateConfig(root, { privacy: next });
+        privacy.set(next.terms ?? [], next.marker);
+        await room.record('privacy.updated', { terms: privacy.terms.length, marker: privacy.marker });
+        return sendJson(response, 200, { terms: privacy.terms, marker: privacy.marker, exposure: room.privacyExposure(await store.readAll()) });
+      }
+      if (request.method === 'POST' && url.pathname === '/api/privacy/purge') {
+        const payload = await body(request).catch(() => ({}));
+        if (!designationOk(payload.designation)) return sendJson(response, 403, { error: 'UNABLE TO COMPUTE. UNABLE TO CLARIFY.' });
+        await refreshPrivacy();
+        if (!privacy.enabled) return sendJson(response, 412, { error: 'No private terms are set. Write them first.' });
+        const result = await room.purgePrivate();
+        // The log was rewritten in place: the broadcaster's byte offset is stale, the sequences are not.
+        tailOffset = (await store.tail(0)).offset;
+        return sendJson(response, 200, { purged: result, exposure: room.privacyExposure(await store.readAll()) });
+      }
+      // The human's verdict on a reply, for the dataset: good, bad, none.
+      if (request.method === 'POST' && url.pathname === '/api/messages/rate') {
+        const payload = await body(request).catch(() => ({}));
+        try {
+          const event = await room.rateMessage(String(payload.messageId ?? ''), String(payload.rating ?? ''));
+          return sendJson(response, 200, { rated: event.payload });
+        } catch (error) { return sendJson(response, 400, { error: error.message }); }
+      }
+      // Release channel: current, latest on npm, and the command for how this copy runs.
+      if (request.method === 'GET' && url.pathname === '/api/version') {
+        return sendJson(response, 200, await versionView({ force: url.searchParams.get('force') === '1' }));
+      }
+      if (request.method === 'POST' && url.pathname === '/api/updates/settings') {
+        const patch = await body(request).catch(() => ({}));
+        if (typeof patch.check === 'boolean') { updatesConfig = { ...updatesConfig, check: patch.check }; await updateConfig(root, { updates: updatesConfig }); }
+        return sendJson(response, 200, { updates: { check: updatesEnabled(), envWins: process.env.PULSE_UPDATE_CHECK !== undefined } });
+      }
       if (request.method === 'GET' && url.pathname === '/api/mother') {
         return sendJson(response, 200, { mother: room.motherStatus(), strikes: CODE000_STRIKES });
       }
@@ -673,7 +860,7 @@ export async function createPulseServer({
         return sendJson(response, result.ok ? 200 : 422, { command: parsed.name, title: result.title, ok: result.ok, sequence: event.sequence });
       }
       if (request.method === 'GET' && url.pathname === '/api/extensions') {
-        return sendJson(response, 200, { installing, extensions: await listExtensions({ projectRoot: canonicalProjectRoot, agents, config: await readConfig(root), imageKey }) });
+        return sendJson(response, 200, { installing, extensions: await describeModules(await moduleContext()) });
       }
       const installMatch = request.method === 'POST' && url.pathname.match(/^\/api\/extensions\/([a-z0-9-]+)\/install$/);
       if (installMatch) {
@@ -696,6 +883,7 @@ export async function createPulseServer({
         // hears "no" with a reason instead of a silent log line.
         const gate = await room.modeCheck(payload);
         if (!gate.ok) return sendJson(response, gate.status ?? 403, { error: gate.error, mode: gate.mode, maxMode: gate.maxMode });
+        await refreshPrivacy();
         void room.send(payload).catch((error) => {
           console.error(`MADRE room error: ${error.message}`);
         });

package/src/setup.mjs

@@ -48,13 +48,21 @@ const glyphFor = (agent, probe) => {
   return '◌';
 };
 
+// Ollama, when it runs with a chat model, is an agent of its own: @madre. Tests hand in a probe.
+export async function localIntelligence(env = process.env) {
+  if (env.PULSE_OLLAMA === '0') return { running: false, chatModel: null, embedModel: null, disabled: true };
+  const { probeOllama } = await import('./ollama.mjs');
+  return probeOllama({ env });
+}
+export const madreOnline = (ollama) => Boolean(ollama?.running && ollama.chatModel);
+
 export function isOnline(agent, probe) {
   return Boolean(agent.ready && probe?.state === 'signed-in');
 }
 
 /* ---------- report (pure, testable) ---------- */
 
-export function renderReport({ agents, probes, projectRoot, config = {}, palette = makePalette({ colors: false }), width = 72 }) {
+export function renderReport({ agents, probes, projectRoot, config = {}, palette = makePalette({ colors: false }), width = 72, ollama = null }) {
   const p = palette;
   const bar = p.phosphor('▌');
   const lines = [];
@@ -83,11 +91,19 @@ export function renderReport({ agents, probes, projectRoot, config = {}, palette
       lines.push(`  ${p.dim('│')}   ${p.dim(model ? `model ${model}` : 'model: provider default (set one if the default provider has no session)')}`);
     }
   }
+  if (ollama && !ollama.disabled) {
+    const local = madreOnline(ollama);
+    const status = local ? p.phosphor('RUNNING   ') : ollama.running ? p.warn('NO MODEL  ') : p.dim('NOT FOUND ');
+    const detail = local ? `@madre in the room · ${ollama.chatModel}${ollama.embedModel ? ` · embeddings ${ollama.embedModel}` : ''}` : ollama.running ? 'pull a chat model: ollama pull qwen2.5:3b' : 'optional: ollama serve · local memory, embeddings and @madre';
+    lines.push(`  ${p.dim('│')} ${p.phosphor('◉')} ${p.phosphor('OLLAMA'.padEnd(9))} ${p.dim('local'.padEnd(10))} ${status} ${p.dim(detail)}`);
+  }
   lines.push(`  ${p.dim('└' + '─'.repeat(Math.max(4, width - 4)))}`);
   const online = agents.filter((agent) => isOnline(agent, probes[agent.id]));
+  const local = madreOnline(ollama);
   const verdict = online.length
-    ? `${online.length} OF ${agents.length} AGENTS ONLINE. ROOM CAN OPEN.`
-    : `NO AGENT ONLINE. CONFIGURE ONE TO OPEN THE ROOM.`;
+    ? `${online.length} OF ${agents.length} AGENTS ONLINE${local ? ' · @MADRE LOCAL' : ''}. ROOM CAN OPEN.`
+    : local ? 'NO CLI ONLINE · @MADRE (LOCAL) IS. THE ROOM CAN OPEN WITH MEMORY ALONE; CONNECT A CLI TO WORK ON FILES.'
+      : `NO AGENT ONLINE. CONFIGURE ONE TO OPEN THE ROOM.`;
   lines.push('');
   lines.push(`  ${p.phosphor('MOTHER')}${p.dim(' ›')} ${p.bold(verdict)}`);
   return lines.join('\n');
@@ -119,12 +135,14 @@ export async function runSetup({ projectRoot, stateRoot, interactive = stdin.isT
   let agents = await detectAgents();
   let probes = await probeAll(agents);
   let config = await loadConfig(stateRoot);
-  log(renderReport({ agents, probes, projectRoot, config, palette: p }));
+  const ollama = await localIntelligence();
+  log(renderReport({ agents, probes, projectRoot, config, palette: p, ollama }));
+  const anyoneOnline = () => agents.some((agent) => isOnline(agent, probes[agent.id])) || madreOnline(ollama);
 
   if (!interactive) {
     // Without a terminal there is nobody to walk through; report and hand
     // back. `online` lets the caller decide (exit codes, CI checks).
-    return { action: 'report', online: agents.some((agent) => isOnline(agent, probes[agent.id])), agents, probes };
+    return { action: 'report', online: anyoneOnline(), agents, probes, ollama };
   }
 
   const rl = createInterface({ input: stdin, output: stdout });
@@ -136,7 +154,7 @@ export async function runSetup({ projectRoot, stateRoot, interactive = stdin.isT
       const answer = (await ask('select')).trim().toLowerCase();
       if (answer === 'q') return { action: 'quit', agents, probes };
       if (answer === 's') {
-        if (!agents.some((agent) => isOnline(agent, probes[agent.id]))) {
+        if (!anyoneOnline()) {
           log(`  ${p.warn('MOTHER ›')} no agent online; the room would open empty. Configure one first or press s again to open anyway.`);
           const again = (await ask('start anyway? [y/N]')).trim().toLowerCase();
           if (again !== 'y') continue;
@@ -147,7 +165,7 @@ export async function runSetup({ projectRoot, stateRoot, interactive = stdin.isT
         agents = await detectAgents();
         probes = await probeAll(agents);
         config = await loadConfig(stateRoot);
-        log(renderReport({ agents, probes, projectRoot, config, palette: p }));
+        log(renderReport({ agents, probes, projectRoot, config, palette: p, ollama }));
         continue;
       }
       if (answer === 'm') {

package/src/updates.mjs

@@ -0,0 +1,79 @@
+// Release channel: is there a newer MADRE on npm? One read of the public registry, at most
+// once a day, cached in ~/.pulse/updates.json. It sends the package name and nothing else,
+// the same request `npx` makes; PULSE_UPDATE_CHECK=0 or the switch in MU/TH/UR turns it off.
+// MADRE never updates itself: the room is in use and the process belongs to the human. It
+// shows the exact command for how this copy was launched.
+
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { dirname } from 'node:path';
+
+export const REGISTRY = 'https://registry.npmjs.org';
+export const UPDATE_TTL_MS = 24 * 60 * 60 * 1000;
+
+const parse = (version) => String(version ?? '').trim().replace(/^v/, '').split(/[.+-]/).slice(0, 3).map((part) => Number.parseInt(part, 10) || 0);
+
+// -1 when a < b, 0 when equal, 1 when a > b. Pre-release tags are ignored: a room compares releases.
+export function compareVersions(a, b) {
+  const [x, y] = [parse(a), parse(b)];
+  for (let i = 0; i < 3; i += 1) if (x[i] !== y[i]) return x[i] < y[i] ? -1 : 1;
+  return 0;
+}
+
+// How this copy runs, from the path of the script Node started: npx cache, the project's own
+// node_modules, a global install, or the source tree.
+export function detectInstall({ script = process.argv[1] ?? '', projectRoot = process.cwd() } = {}) {
+  const path = String(script).replace(/\\/g, '/');
+  if (/\/_npx\//.test(path)) return 'npx';
+  if (projectRoot && path.startsWith(`${String(projectRoot).replace(/\\/g, '/').replace(/\/$/, '')}/node_modules/`)) return 'project';
+  if (/\/node_modules\//.test(path)) return 'global';
+  return 'source';
+}
+
+export function updateCommand(install, name, version = 'latest') {
+  switch (install) {
+    case 'npx': return `npx ${name}@${version} start`;
+    case 'project': return `npm install ${name}@${version}`;
+    case 'global': return `npm install -g ${name}@${version}`;
+    default: return 'git pull';
+  }
+}
+
+export function releaseUrl(repository, version) {
+  const url = String(repository?.url ?? repository ?? '').replace(/^git\+/, '').replace(/\.git$/, '');
+  return url ? `${url}/releases/tag/v${version}` : null;
+}
+
+async function readCache(file) {
+  try { return JSON.parse(await readFile(file, 'utf8')); } catch { return null; }
+}
+
+// The check. `enabled: false` answers from the cache only and never touches the network.
+export async function checkForUpdate({ name, current, cacheFile, fetchImpl = globalThis.fetch, now = Date.now(), ttlMs = UPDATE_TTL_MS, enabled = true, force = false, timeoutMs = 4000 } = {}) {
+  const cached = cacheFile ? await readCache(cacheFile) : null;
+  const fresh = cached && cached.name === name && Number.isFinite(cached.checkedAt) && now - cached.checkedAt < ttlMs;
+  let latest = cached?.name === name ? cached.latest ?? null : null;
+  let checkedAt = cached?.name === name ? cached.checkedAt ?? null : null;
+  let source = latest ? 'cache' : 'none';
+  let error = null;
+  if (enabled && (force || !fresh)) {
+    try {
+      const response = await fetchImpl(`${REGISTRY}/${encodeURIComponent(name).replace('%40', '@')}/latest`, { headers: { accept: 'application/json' }, signal: AbortSignal.timeout(timeoutMs) });
+      if (!response.ok) throw new Error(`registry HTTP ${response.status}`);
+      const doc = await response.json();
+      if (typeof doc?.version !== 'string') throw new Error('registry answered without a version');
+      latest = doc.version;
+      checkedAt = now;
+      source = 'registry';
+      if (cacheFile) {
+        await mkdir(dirname(cacheFile), { recursive: true }).catch(() => {});
+        await writeFile(cacheFile, JSON.stringify({ name, latest, checkedAt })).catch(() => {});
+      }
+    } catch (cause) {
+      error = cause.message;
+      if (!latest) source = 'error';
+    }
+  }
+  if (!enabled) source = latest ? 'cache' : 'off';
+  const available = Boolean(latest && current && compareVersions(current, latest) < 0);
+  return { enabled, current: current ?? null, latest, available, checkedAt, source, error };
+}