@jossuealcala/madre 0.2.2 → 0.3.0

package/src/server.mjs

@@ -12,16 +12,34 @@ 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 } from './dataset.mjs';
 
 const PACKAGE = JSON.parse(await readFile(new URL('../package.json', import.meta.url), 'utf8').catch(() => '{}'));
 let crashHandlersInstalled = false;
+
+// RIPLEY's bridge, injected into every page it renders: reports the page's path
+// and title to the viewer and forwards runtime errors and failed resources.
+// It talks only upward through postMessage; the frame stays an opaque origin.
+export const RIPLEY_BRIDGE = '<script data-ripley>(function(){var p=location.pathname;function send(m){try{parent.postMessage(Object.assign({ripley:1},m),"*")}catch(e){}}send({type:"page",path:p,title:document.title});addEventListener("DOMContentLoaded",function(){send({type:"page",path:p,title:document.title})});addEventListener("error",function(e){if(e.target&&e.target!==window&&!e.message){var u=e.target.src||e.target.href||"";send({type:"error",message:"Failed to load "+(u||e.target.tagName.toLowerCase()),source:u,line:0});return}send({type:"error",message:String(e.message||"error"),source:e.filename||"",line:e.lineno||0})},true);addEventListener("unhandledrejection",function(e){var r=e.reason;send({type:"error",message:"Unhandled promise rejection: "+String(r&&r.message||r),source:"",line:0})})})();</script>';
+export function injectRipleyBridge(body) {
+  const text = Buffer.isBuffer(body) ? body.toString('utf8') : String(body);
+  if (text.includes('data-ripley')) return Buffer.from(text);
+  const head = text.match(/<head[^>]*>/i);
+  if (head) return Buffer.from(text.slice(0, head.index + head[0].length) + RIPLEY_BRIDGE + text.slice(head.index + head[0].length));
+  const html = text.match(/<html[^>]*>/i);
+  if (html) return Buffer.from(text.slice(0, html.index + html[0].length) + RIPLEY_BRIDGE + text.slice(html.index + html[0].length));
+  return Buffer.from(RIPLEY_BRIDGE + text);
+}
 // The author's collector: SEND and AUTO-REPORT are available out of the box; AUTO-REPORT stays off until the human turns it on.
 const DEFAULT_REPORT_URL = 'https://madre-reports.jossue-alcala-o.workers.dev/v1/reports';
 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 { discoverModels } from './models.mjs';
@@ -97,12 +115,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));
@@ -115,21 +135,68 @@ export async function createPulseServer({
     .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 ?? {}) });
+  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,
     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,
@@ -140,6 +207,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?.();
@@ -167,6 +235,19 @@ 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(),
+    };
+  }
+  // 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) {
@@ -194,6 +275,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 };
@@ -212,6 +308,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();
   }
@@ -355,38 +452,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: [] };
@@ -460,7 +571,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 },
@@ -523,26 +634,34 @@ export async function createPulseServer({
         });
         return response.end(file.body);
       }
-      // RIPLEY: the same file, served to be rendered, inside a frame that may run
-      // nothing, load nothing from outside and keep nothing.
-      if (request.method === 'GET' && url.pathname === '/api/preview') {
-        if (!ripleyEnabled) return sendJson(response, 412, { error: 'RIPLEY is off. Enable it in MODULES to render files.' });
-        const which = url.searchParams.get('root') === 'attachments' ? attachmentsRoot : canonicalProjectRoot;
-        const relative = url.searchParams.get('path') ?? '';
-        const kind = /\.(html?|xhtml)$/i.test(relative) ? 'text/html; charset=utf-8' : /\.svg$/i.test(relative) ? 'image/svg+xml' : null;
-        if (!kind) return sendJson(response, 415, { error: 'RIPLEY renders .html and .svg here; Markdown is rendered in the viewer itself.' });
+      // RIPLEY: the project rendered as a site, inside a frame that runs scripts but
+      // reaches nothing: an opaque origin (sandbox without same-origin), no network
+      // (connect-src none), no forms, no top navigation, assets only from MADRE's
+      // own host. Path-based, so a page's relative links to its CSS, JS and images
+      // resolve to the same route.
+      const previewMatch = request.method === 'GET' && url.pathname.match(/^\/preview\/(project|attachments)\/(.*)$/);
+      if (previewMatch) {
+        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);
         if (file.status !== 200) return sendJson(response, file.status, { error: file.error });
-        response.writeHead(200, {
-          'content-type': kind,
-          'content-length': file.size,
+        const isPage = /\.(html?|xhtml)$/i.test(relative);
+        const origin = `${request.headers['x-forwarded-proto'] ?? 'http'}://${request.headers.host ?? '127.0.0.1'}`;
+        // Pages carry RIPLEY's bridge: one inline script that tells the viewer which
+        // page loaded and forwards the page's own errors. Nothing else is touched.
+        const bodyOut = isPage ? injectRipleyBridge(file.body) : file.body;
+        const headers = {
+          'content-type': isPage ? 'text/html; charset=utf-8' : file.contentType,
+          'content-length': Buffer.byteLength(bodyOut),
           'cache-control': 'no-store',
           'x-content-type-options': 'nosniff',
           'referrer-policy': 'no-referrer',
-          'content-security-policy': "sandbox; default-src 'none'; img-src 'self' data: blob:; style-src 'self' 'unsafe-inline'; font-src 'self' data:; media-src 'self' data:; form-action 'none'; base-uri 'none'",
           'content-disposition': `inline; filename="${encodeURIComponent(basename(file.path))}"`,
-        });
-        return response.end(file.body);
+        };
+        if (isPage) headers['content-security-policy'] = `sandbox allow-scripts; default-src 'none'; script-src 'unsafe-inline' ${origin}; style-src 'unsafe-inline' ${origin}; img-src ${origin} data: blob:; font-src ${origin} data:; media-src ${origin} data: blob:; connect-src 'none'; frame-src 'none'; object-src 'none'; form-action 'none'; base-uri 'none'`;
+        response.writeHead(200, headers);
+        return response.end(bodyOut);
       }
       if (request.method === 'POST' && url.pathname === '/api/attachments') {
         let bytes;
@@ -580,6 +699,24 @@ 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');
+        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 });
+        }
+        const result = await exportDataset({ events: await store.readAll(), notes: memory ? memory.memories({ limit: 5000 }) : [], dir, project: basename(canonicalProjectRoot), home: homedir() });
+        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 });
+      }
       if (request.method === 'GET' && url.pathname === '/api/mother') {
         return sendJson(response, 200, { mother: room.motherStatus(), strikes: CODE000_STRIKES });
       }
@@ -651,7 +788,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) {

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') {