@jossuealcala/madre 0.7.2 → 1.0.1

package/src/modules/ollama.mjs

@@ -46,7 +46,7 @@ export async function ollamaView(probe, settings) {
 
 export default defineModule({
   id: 'ollama',
-  name: 'OLLAMA',
+  name: 'Local AI',
   vendor: 'MADRE · LOCAL INTELLIGENCE',
   tracks: { name: 'ollama', github: 'ollama/ollama' },
   summary: 'Recall by meaning and memory distillation on this machine, through Ollama: no provider tokens, nothing leaves.',
@@ -59,15 +59,18 @@ export default defineModule({
     const view = await ollamaView(probe, ctx.settings);
     const binary = view.binary;
     const settings = ctx.settings;
-    const roles = [settings.embeddings && probe.embedModel ? `${t('embeddings')} · ${probe.embedModel}` : null, settings.archivist && probe.chatModel ? `${t('archivist')} · ${probe.chatModel}` : null, settings.agent !== false && probe.chatModel ? t('@madre in the room') : null].filter(Boolean);
+    const roles = [settings.embeddings && probe.embedModel ? `${t('smart search')} · ${probe.embedModel}` : null, settings.archivist && probe.chatModel ? `${t('archivist')} · ${probe.chatModel}` : null, settings.agent !== false && probe.chatModel ? t('@madre in the project') : null].filter(Boolean);
+    // Home can leave this one project without the local AI while the module stays on (src/local-ai.mjs).
+    const project = await ctx.services.ollama?.project?.() ?? { on: true };
     const detail = !probe.running ? (binary ? t('installed, not running · START it here') : t('not installed · INSTALL it here'))
       : !settings.enabled ? t('off · {n} models available', { n: probe.models.length })
+        : !project.on ? t('off in this project · Home › Settings › Local AI')
         : roles.length ? `${t('on')} · ${roles.join(' · ')}` : t('on · no usable model yet · PULL one');
     return {
       runs: [{ name: 'ollama', version: probe.version ?? null }],
       models: probe.models.map((model) => model.name),
-      status: { installed: settings.enabled && probe.running && roles.length > 0, detail },
-      ollama: view,
+      status: { installed: settings.enabled && project.on && probe.running && roles.length > 0, detail },
+      ollama: { ...view, project },
       recommended: RECOMMENDED,
       preflight: probe.running ? { ok: true, problems: [] } : { ok: false, problems: ['Ollama is not running: open the Ollama app or run `ollama serve`, then RECHECK.'] },
       install: { display: settings.enabled ? 'disable Ollama' : 'enable Ollama (config.json)', platforms: [] },
@@ -82,8 +85,17 @@ export default defineModule({
     return { ...plan, note: `${plan.note} If an older Ollama is still the one answering, MADRE restarts it so the new one does.`, after: () => ctx.services.ollama.restart?.() ?? null };
   },
   async toggle(ctx) {
+    // Outside «auto» the switch on this card is this project's: it never turns the local AI off
+    // for every other project (src/local-ai.mjs). In «auto», or with it off for all, it is the
+    // switch for every project, as it always was.
+    const project = await ctx.services.ollama?.project?.();
+    if (project?.editable && project.master) {
+      const status = await ctx.services.ollama.setProject(!project.chosen);
+      await ctx.record('extension.toggled', { id: 'ollama', name: 'OLLAMA', enabled: !project.chosen, project: true });
+      return { status: 200, body: { enabled: !project.chosen, ollama: status } };
+    }
     const enabled = !(ctx.settings.enabled ?? true);
-    await ctx.updateConfig({ modules: { ...(ctx.config.modules ?? {}), ollama: { ...(ctx.config.modules?.ollama ?? {}), enabled } } });
+    await ctx.updateConfig({ modules: { ollama: { ...(ctx.config.modules?.ollama ?? {}), enabled } } });
     const status = await ctx.services.ollama.wire();
     await ctx.record('extension.toggled', { id: 'ollama', name: 'OLLAMA', enabled });
     return { status: 200, body: { enabled, ollama: status } };
@@ -94,7 +106,7 @@ export default defineModule({
     { method: 'POST', path: '/api/ollama/settings', handler: async (ctx, { payload }) => {
       const next = { ...(ctx.config.modules?.ollama ?? {}) };
       for (const key of ['embeddings', 'archivist', 'agent', 'enabled']) if (typeof payload[key] === 'boolean') next[key] = payload[key];
-      await ctx.updateConfig({ modules: { ...(ctx.config.modules ?? {}), ollama: next } });
+      await ctx.updateConfig({ modules: { ollama: next } });
       return { status: 200, body: { ollama: await ctx.services.ollama.wire({ probe: false }) } };
     } },
     { method: 'POST', path: '/api/ollama/install', handler: async (ctx) => {

package/src/modules/playwright.mjs

@@ -3,10 +3,14 @@
 // scratch folder. Runs @playwright/mcp per turn, isolated, with allowed origins limited to the
 // room's own address: nothing else on the network is reachable through it.
 
+import { spawn } from 'node:child_process';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { t } from '../i18n.mjs';
 import { defineModule } from './sdk.mjs';
 import { packageVersion } from './helpers.mjs';
+import { terminateProcessTree, lastWords } from '../adapters/process.mjs';
 
 export const PLAYWRIGHT_PACKAGE = '@playwright/mcp';
 export const PLAYWRIGHT_BROWSERS = ['chromium', 'firefox', 'webkit'];
@@ -25,7 +29,94 @@ export async function playwrightVersion({ env = process.env, projectRoot = proce
   return version;
 }
 
-export function playwrightServerFor({ port, outputDir, browser = 'chromium', headless = true }) {
+// Does the browser server start, with its browser? Asked when the switch is turned on, with the
+// same server a turn gets: the card said «on · chromium» while every turn's server closed before it
+// spoke, and the agents saw only CONNECTION_CLOSED. It is asked to open about:blank, because a
+// server without its browser starts fine and fails only at the first page.
+export async function playwrightStarts({ browser = 'chromium', env = process.env, cwd = process.cwd(), timeoutMs = 60000, command = 'npx', args = null } = {}) {
+  // npx is a .cmd shim on Windows and there is no shell to run it (WIN-027): not asked there.
+  if (process.platform === 'win32' && command === 'npx') return { ok: true, checked: false };
+  const outputDir = await mkdtemp(join(tmpdir(), 'madre-playwright-'));
+  const argv = args ?? ['--no', PLAYWRIGHT_PACKAGE, '--', '--headless', '--isolated', '--browser', browser, '--output-dir', outputDir, '--no-sandbox'];
+  return new Promise((resolve) => {
+    let child = null;
+    let out = '';
+    let err = '';
+    let settled = false;
+    let timer = null;
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      if (child) terminateProcessTree(child, { graceMs: 1000 });
+      rm(outputDir, { recursive: true, force: true }).catch(() => {});
+      resolve(result);
+    };
+    try {
+      child = spawn(command, argv, { cwd, env, stdio: ['pipe', 'pipe', 'pipe'], shell: false, detached: true, windowsHide: true });
+    } catch (error) {
+      finish({ ok: false, problem: error.message });
+      return;
+    }
+    timer = setTimeout(() => finish({ ok: false, problem: t('it did not answer within {seconds}s', { seconds: Math.round(timeoutMs / 1000) }) }), timeoutMs);
+    timer.unref?.();
+    const send = (message) => { if (!settled) child.stdin.write(`${JSON.stringify(message)}\n`); };
+    child.stdin.on('error', () => {});
+    child.stdout.setEncoding('utf8');
+    child.stderr.setEncoding('utf8');
+    child.stdout.on('data', (chunk) => {
+      out += chunk;
+      for (let newline = out.indexOf('\n'); newline >= 0; newline = out.indexOf('\n')) {
+        const line = out.slice(0, newline).trim();
+        out = out.slice(newline + 1);
+        let message;
+        try { message = JSON.parse(line); } catch { continue; }
+        if (message.id === 1) {
+          if (message.error) { finish({ ok: false, problem: String(message.error.message ?? 'initialize failed') }); return; }
+          send({ jsonrpc: '2.0', method: 'notifications/initialized' });
+          send({ jsonrpc: '2.0', id: 2, method: 'tools/call', params: { name: 'browser_navigate', arguments: { url: 'about:blank' } } });
+        } else if (message.id === 2) {
+          // The reason, without the path of the executable it looked for or the command it suggests:
+          // the card and the refusal say what to run, in the room's words.
+          const said = (message.result?.content ?? []).map((part) => part?.text ?? '').join(' ').replace(/^#+\s*Error\s*/i, '').replace(/^Error:\s*/i, '').replace(/;\s*expected executable at[\s\S]*$/i, '').replace(/\s+/g, ' ').trim();
+          if (message.error || message.result?.isError) { finish({ ok: false, problem: String(message.error?.message ?? said).slice(0, 300) }); return; }
+          finish({ ok: true, checked: true });
+          return;
+        }
+      }
+    });
+    child.stderr.on('data', (chunk) => { err += chunk; });
+    child.on('error', (error) => finish({ ok: false, problem: error.message }));
+    child.on('close', (code) => finish({ ok: false, problem: lastWords(err) ?? t('it exited with code {code} before it spoke', { code }) }));
+    send({ jsonrpc: '2.0', id: 1, method: 'initialize', params: { protocolVersion: '2025-03-26', capabilities: {}, clientInfo: { name: 'madre', version: '1' } } });
+  });
+}
+
+// A turn that asks to look at a page, click through it, test it, read its console or take a picture
+// of it, in the two languages the crew is spoken to here. A page merely named is not one: «cambia el
+// lema de la página» needs no browser.
+export const BROWSER_INTENT = /navegador|browser|playwright|captura|screenshot|pantallazo|\bclic|\bclick|consola|console|responsive|m[oó]vil|mobile|viewport|ancho de|se ve\b|c[oó]mo (se )?ve|visual|vista previa|preview|ripley|interfaz|\bui\b|\bux\b|e2e|end.to.end|pru[eé]ba(lo|la|las|los)? en|test (it|the page|in the browser)|abre (la|el) (p[aá]gina|app|sitio)|open the (page|app|site)|smoke test/i;
+export const wantsBrowser = (text) => BROWSER_INTENT.test(String(text ?? ''));
+
+// The last answer to «does it start?», for a switch that was already on: asked again in the
+// background at most every ten minutes, so the card can say the browser is missing and no turn
+// carries a server that would only fail.
+let started = { at: 0, result: null, asking: null };
+export function playwrightHealth({ browser = 'chromium', env = process.env, cwd = process.cwd(), now = Date.now(), check = playwrightStarts } = {}) {
+  if (env.PULSE_PLAYWRIGHT_CHECK === '0') return started.result;
+  if (!started.asking && now - started.at > 10 * 60 * 1000) {
+    started.asking = check({ browser, env, cwd }).then((result) => { started = { at: Date.now(), result, asking: null }; return result; }, () => { started.asking = null; return null; });
+  }
+  return started.result;
+}
+export function forgetPlaywrightHealth(result = null) { started = { at: result ? Date.now() : 0, result, asking: null }; }
+
+// What the browser may open: this room, and the servers the human started from RUNS in this project
+// while they listen on 127.0.0.1. RIPLEY's sealed frame keeps no data, so an app that stores its
+// data could only be tried through it half-blind. Nothing else on the network.
+export function playwrightServerFor({ port, outputDir, browser = 'chromium', headless = true, servers = [] }) {
+  const origins = [port, ...servers.filter((one) => Number.isInteger(one) && one !== port)].flatMap((one) => [`http://127.0.0.1:${one}`, `http://localhost:${one}`]);
+  const served = servers.filter((one) => Number.isInteger(one) && one !== port);
   return {
     name: PLAYWRIGHT_SERVER_NAME,
     command: 'npx',
@@ -36,21 +127,21 @@ export function playwrightServerFor({ port, outputDir, browser = 'chromium', hea
     // abort and then routes each allowed origin to continue, and Playwright matches the most
     // recently added route first — so a blocked `*`, registered after both, wins over the
     // allowlist and aborts even this room with ERR_BLOCKED_BY_CLIENT.
-    args: ['--no', '@playwright/mcp', '--', ...(headless ? ['--headless'] : []), '--isolated', '--browser', browser, '--allowed-origins', `http://127.0.0.1:${port};http://localhost:${port}`, '--output-dir', outputDir, '--no-sandbox'],
+    args: ['--no', '@playwright/mcp', '--', ...(headless ? ['--headless'] : []), '--isolated', '--browser', browser, '--allowed-origins', origins.join(';'), '--output-dir', outputDir, '--no-sandbox'],
     env: {},
     tools: PLAYWRIGHT_TOOLS,
-    brief: `a headless browser that reaches only this MADRE at http://127.0.0.1:${port}. Open a project file rendered by RIPLEY at http://127.0.0.1:${port}/preview/project/<path>, click, read the console and network, take screenshots (they land in ${outputDir}). Nothing else on the network is reachable through it.`,
+    brief: `a headless browser that reaches only this MADRE at http://127.0.0.1:${port}${served.length ? ` and the project's servers the human started (${served.map((one) => `http://127.0.0.1:${one}`).join(', ')})` : ''}. Open a project file rendered by RIPLEY at http://127.0.0.1:${port}/preview/project/<path>, click, read the console and network, take screenshots (they land in ${outputDir}). RIPLEY's preview keeps no data (no localStorage, no cookies)${served.length ? '; to try an app with its data, open it on its server' : ''}. Nothing else on the network is reachable through it.`,
   };
 }
 
 export default defineModule({
   id: 'playwright',
-  name: 'PLAYWRIGHT',
+  name: 'Test browser',
   vendor: 'MADRE · Playwright MCP',
   tracks: { name: PLAYWRIGHT_PACKAGE, npm: PLAYWRIGHT_PACKAGE },
-  summary: 'Hands every agent a headless browser that reaches only this room: it opens the RIPLEY preview of a page, clicks through it, reads the console and takes screenshots.',
-  creates: ['nothing in the project \u00b7 screenshots land in .pulse/out/<turn>/', 'a switch in ~/.pulse/config.json', 'a browser per turn, started and stopped by the CLI', 'no origin but this room is reachable through it'],
-  requires: ['@playwright/mcp and a chromium browser on this machine', 'RIPLEY on, to have pages to open'],
+  summary: 'Hands an agent a headless browser that reaches only this project and the servers you start from COMMANDS, on the turns that ask to look at a page, click through it, read its console or take screenshots.',
+  creates: ['nothing in the project \u00b7 screenshots land in .pulse/out/<turn>/', 'a switch in ~/.pulse/config.json', 'a browser per turn, started and stopped by the CLI', 'no origin but this project is reachable through it'],
+  requires: ['@playwright/mcp and a chromium browser on this machine', 'PREVIEW on, to have pages to open'],
   settings: { enabled: false, browser: 'chromium', headless: true },
   card: 'switch',
   controls: [
@@ -59,10 +150,11 @@ export default defineModule({
   ],
   async status(ctx) {
     const version = await playwrightVersion({ env: ctx.env, projectRoot: ctx.projectRoot });
+    const health = ctx.settings.enabled && version ? playwrightHealth({ browser: ctx.settings.browser ?? 'chromium', env: ctx.env, cwd: ctx.projectRoot }) : null;
     return {
       runs: [{ name: PLAYWRIGHT_PACKAGE, version }],
       settings: { browser: ctx.settings.browser ?? 'chromium', headless: ctx.settings.headless !== false },
-      status: { installed: Boolean(ctx.settings.enabled), detail: ctx.settings.enabled ? (version ? `${t('on')} · ${ctx.settings.browser}` : t('on · the browser server is not installed')) : version ? t('off') : t('off · the browser server is not installed') },
+      status: { installed: Boolean(ctx.settings.enabled), detail: ctx.settings.enabled ? (!version ? t('on · the browser server is not installed') : health?.ok === false ? t('on · the browser does not start: {problem}', { problem: String(health.problem).slice(0, 160) }) : `${t('on')} · ${ctx.settings.browser}`) : version ? t('off') : t('off · the browser server is not installed') },
       preflight: version ? { ok: true, problems: [] } : { ok: false, problems: ['Install the browser server first: npm install -g @playwright/mcp, then its browser: npx @playwright/mcp install-browser chrome-for-testing'] },
       install: { display: ctx.settings.enabled ? 'disable PLAYWRIGHT' : 'enable PLAYWRIGHT (config.json)', platforms: ['codex', 'claude', 'gemini', 'opencode'] },
     };
@@ -82,16 +174,34 @@ export default defineModule({
   async toolsForTurn(ctx, turn) {
     if (!(await playwrightVersion({ env: ctx.env, projectRoot: ctx.projectRoot }))) return [];
     if (turn.mode === 0) return [];   // a ghost turn leaves no screenshots and opens no browser
+    // Only for a turn that asks for what a browser does. Its tool list goes into every call the CLI
+    // makes inside the turn: a one-line change cost Codex 576 thousand tokens of reading, and the
+    // browser it carried was never opened.
+    if (turn.text !== undefined && !wantsBrowser(turn.text)) return [];
+    // A browser known not to start is not handed to anyone: every call to it would fail.
+    if (playwrightHealth({ browser: ctx.settings.browser ?? 'chromium', env: ctx.env, cwd: ctx.projectRoot })?.ok === false) return [];
     const outputDir = turn.scratchDir ?? join(turn.roomDir ?? ctx.stateRoot, 'playwright');
-    return [playwrightServerFor({ port: turn.port, outputDir, browser: ctx.settings.browser ?? 'chromium', headless: ctx.settings.headless !== false })];
+    return [playwrightServerFor({ port: turn.port, outputDir, browser: ctx.settings.browser ?? 'chromium', headless: ctx.settings.headless !== false, servers: turn.servers ?? [] })];
+  },
+  // The switch, guarded: on only if the server starts and has its browser. Off is always allowed.
+  async toggle(ctx) {
+    const enabled = !ctx.settings.enabled;
+    if (enabled) {
+      const check = await playwrightStarts({ browser: ctx.settings.browser ?? 'chromium', env: ctx.env, cwd: ctx.projectRoot });
+      forgetPlaywrightHealth(check);
+      if (!check.ok) return { status: 412, body: { error: t('TEST BROWSER did not start, so it stays off: {problem}. Install the server and its browser (npm install -g @playwright/mcp, then npx @playwright/mcp install-browser chrome-for-testing) and turn it on again.', { problem: String(check.problem).replace(/[.\s]+$/, '') }), code: 'MU-054' } };
+    }
+    await ctx.updateConfig({ modules: { playwright: { ...(ctx.config.modules?.playwright ?? {}), enabled } } });
+    await ctx.record('extension.toggled', { id: 'playwright', name: 'PLAYWRIGHT', enabled });
+    return { status: 200, body: { enabled } };
   },
   conditions: [{
     id: 'playwright-missing',
     code: 'MU-054',
     severity: 'informational',
-    title: 'PLAYWRIGHT: the browser server is not installed',
+    title: 'TEST BROWSER: the browser server is not installed',
     match: /@playwright\/mcp|playwright.*not (found|installed)|browser server/i,
-    diagnosis: 'The PLAYWRIGHT module runs @playwright/mcp per turn. Two different things have to be on this computer and only one of them is the package: the server, and the browser build that this version of it expects. A server that starts without its browser answers every tool call with "Browser … is not installed", and one that cannot start at all reaches the agent as CONNECTION_CLOSED.',
+    diagnosis: 'The TEST BROWSER module runs @playwright/mcp per turn. Two different things have to be on this computer and only one of them is the package: the server, and the browser build that this version of it expects. A server that starts without its browser answers every tool call with "Browser … is not installed", and one that cannot start at all reaches the agent as CONNECTION_CLOSED.',
     remedy: 'Install the server once, globally, then its browser — the browser is downloaded by the server itself, not by the playwright CLI — and RECHECK in MODULES.',
     fixes: { darwin: ['npm install -g @playwright/mcp', 'npx @playwright/mcp install-browser chrome-for-testing'], linux: ['npm install -g @playwright/mcp', 'npx @playwright/mcp install-browser chrome-for-testing'] },
   }],

package/src/modules/ripley.mjs

@@ -6,7 +6,7 @@ import { t } from '../i18n.mjs';
 
 export default defineModule({
   id: 'ripley',
-  name: 'RIPLEY',
+  name: 'Preview',
   vendor: 'MADRE · PREVIEW',
   version: '1.0.0',
   summary: 'Renders HTML, SVG and Markdown from the project in the file viewer, inside a sealed frame, and opens a browser on the servers answering on this computer.',

package/src/modules/runs.mjs

@@ -19,10 +19,10 @@ import { t } from '../i18n.mjs';
 export default defineModule({
   id: 'runs',
   configKey: 'runs',
-  name: 'Runs',
+  name: 'Commands',
   vendor: 'MADRE',
   version: '1.0.0',
-  summary: 'Lets an agent ask you to run a command it cannot run in its mode (tests, a build, a linter). Each command is a button: nothing runs until you press it, it runs from the project root with no shell, a checkpoint is taken first, and the output comes back to the room. Costs about 190 tokens of instruction per turn below AIRLOCK while it is on.',
+  summary: 'Lets an agent ask you to run a command it cannot run in its mode (tests, a build, a linter). Each command is a button: nothing runs until you press it, it runs from the project root with no shell, a restore point is taken first, and the output comes back to the project. Costs about 300 tokens of instruction per turn below FULL ACCESS while it is on.',
   creates: ['nothing in the project', 'a switch in ~/.pulse/config.json'],
   async status(ctx) {
     return {

package/src/modules/sdk.mjs

@@ -103,8 +103,14 @@ export function defineModule(spec) {
       if (!control?.key) throw new Error(`Module ${spec.id}: a control needs a key.`);
       const type = control.type ?? 'switch';
       if (!['select', 'switch', 'text'].includes(type)) throw new Error(`Module ${spec.id}: control ${control.key} has no such type "${type}".`);
-      if (type === 'select' && !control.options?.length) throw new Error(`Module ${spec.id}: control ${control.key} is a select with no options.`);
-      return { key: control.key, label: control.label ?? control.key.toUpperCase(), type, options: control.options ?? [], note: control.note ?? '', invert: Boolean(control.invert) };
+      // A select may say, for each value it saves, the words a person reads: `choices` is
+      // [{ value, label }], and its values are the options. The label is prose, translated with
+      // the rest of the card; the value is what is saved, never shown.
+      const choices = type === 'select' && Array.isArray(control.choices) ? control.choices.filter((choice) => typeof choice?.value === 'string').map((choice) => ({ value: choice.value, label: String(choice.label ?? choice.value) })) : null;
+      const options = control.options ?? choices?.map((choice) => choice.value) ?? [];
+      if (type === 'select' && !options.length) throw new Error(`Module ${spec.id}: control ${control.key} is a select with no options.`);
+      if (choices && choices.some((choice) => !options.includes(choice.value))) throw new Error(`Module ${spec.id}: control ${control.key} has a choice that is not one of its options.`);
+      return { key: control.key, label: control.label ?? control.key.toUpperCase(), type, options, ...(choices ? { choices } : {}), note: control.note ?? '', invert: Boolean(control.invert) };
     }),
     // Where this module's traffic goes, in the same four answers `src/outbound.mjs` demands of
     // MADRE's own destinations. Without it a connector's traffic reads in the log as «an address
@@ -197,7 +203,7 @@ export function defineModule(spec) {
         next = String(value ?? '').slice(0, 500);
       }
       const settings = { ...settingsFrom(ctx.config), [key]: next };
-      await ctx.updateConfig({ modules: { ...(ctx.config.modules ?? {}), [configKey]: { ...(ctx.config.modules?.[configKey] ?? {}), [key]: next } } });
+      await ctx.updateConfig({ modules: { [configKey]: { ...(ctx.config.modules?.[configKey] ?? {}), [key]: next } } });
       if (spec.onSettings) await spec.onSettings(mine(ctx, settings), settings);
       return { status: 200, body: { settings: Object.fromEntries(base.controls.map((known) => [known.key, settings[known.key] ?? null])) } };
     } : null,
@@ -209,7 +215,7 @@ export function defineModule(spec) {
       if (spec.toggle) return spec.toggle(mine(ctx, settings), payload);
       const enabled = !settings.enabled;
       if (enabled && spec.confirm && payload.confirm !== true) return { status: 400, body: { error: spec.confirm } };
-      await ctx.updateConfig({ modules: { ...(ctx.config.modules ?? {}), [configKey]: { ...(ctx.config.modules?.[configKey] ?? {}), enabled } } });
+      await ctx.updateConfig({ modules: { [configKey]: { ...(ctx.config.modules?.[configKey] ?? {}), enabled } } });
       const after = spec.onToggle ? await spec.onToggle(mine(ctx, { ...settings, enabled }), enabled) : null;
       await ctx.record('extension.toggled', { id: spec.id, name: base.name, enabled, ...(spec.toggledEvent ?? {}) });
       return { status: 200, body: { enabled, ...(after ?? {}), ...(spec.toggledBody?.(enabled) ?? {}) } };

package/src/ollama.mjs

@@ -3,6 +3,8 @@
 // so remembering costs no tokens elsewhere and nothing leaves. Nothing here is
 // required: without Ollama every path falls back to what it did before.
 
+import { t } from './i18n.mjs';
+
 export const DEFAULT_OLLAMA_HOST = 'http://127.0.0.1:11434';
 // Embedding models we know how to talk to, best first.
 export const EMBED_MODELS = ['nomic-embed-text', 'mxbai-embed-large', 'snowflake-arctic-embed', 'all-minilm', 'bge-m3'];
@@ -94,7 +96,10 @@ export function ollamaEmbedder({ host = ollamaHost(), model, fetchImpl = globalT
 export async function ollamaGenerate({ host = ollamaHost(), model, prompt, system = null, json = false, fetchImpl = globalThis.fetch, timeoutMs = 180000, temperature = 0.2, numCtx = DEFAULT_NUM_CTX } = {}) {
   const started = Date.now();
   const messages = [...(system ? [{ role: 'system', content: system }] : []), { role: 'user', content: prompt }];
-  const response = await fetchImpl(`${host}/api/chat`, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ model, messages, stream: false, options: { temperature, num_ctx: numCtx }, ...(json ? { format: 'json' } : {}) }), signal: AbortSignal.timeout(timeoutMs) });
+  // A model that takes longer than the turn allows says so in the room's words, as any agent does:
+  // the bare «The operation was aborted due to timeout» reached the person, in English.
+  const response = await fetchImpl(`${host}/api/chat`, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ model, messages, stream: false, options: { temperature, num_ctx: numCtx }, ...(json ? { format: 'json' } : {}) }), signal: AbortSignal.timeout(timeoutMs) })
+    .catch((error) => { throw error?.name === 'TimeoutError' ? new Error(t('{label} did not respond before the timeout ({seconds}s).', { label: `Ollama (${model})`, seconds: Math.round(timeoutMs / 1000) })) : error; });
   if (!response.ok) throw new Error(`Ollama HTTP ${response.status}: ${(await response.text().catch(() => '')).slice(0, 200)}`);
   const payload = await response.json();
   const inputTokens = payload.prompt_eval_count ?? 0;

package/src/outbound.mjs

@@ -22,6 +22,7 @@
 // would be a poor place to leave it.
 
 import { appendFile, mkdir, open, stat, writeFile } from 'node:fs/promises';
+import { t } from './i18n.mjs';
 import { dirname } from 'node:path';
 
 export const KEEP = 200;                 // lines held for the screen
@@ -50,14 +51,14 @@ export const DESTINATIONS = [
     id: 'embeddings', host: 'generativelanguage.googleapis.com', match: (url) => /batchEmbedContents/.test(url.pathname), to: 'Google · Gemini embeddings',
     what: 'The text of what is being embedded: the first 2000 characters of each memory, and the question a recall is made of.',
     when: 'a memory is written or recalled, while embeddings are set to Gemini',
-    where: 'MU/TH/UR → MEMORY → EMBEDDINGS · OLLAMA keeps it on this computer, OFF drops back to words',
+    where: 'Settings › Memory › Smart search · Ollama keeps it on this computer, off drops back to words',
     inside: true,
   },
   {
     id: 'image', host: 'generativelanguage.googleapis.com', match: (url) => /generateContent/.test(url.pathname), to: 'Google · Gemini image model',
     what: 'The prompt an agent wrote for an image.',
     when: 'an agent calls the image tool during a lease',
-    where: 'MODULES → IMAGE STUDIO',
+    where: 'Modules › Images',
     // It runs in a process of its own and writes its own line into this same log, so it is here.
     inside: true,
   },
@@ -65,35 +66,51 @@ export const DESTINATIONS = [
     id: 'npm', host: 'registry.npmjs.org', to: 'the npm registry',
     what: 'The name of a package, to read the version of its latest release. Nothing about you or your project.',
     when: 'at most once a day per package, while the release channel is on',
-    where: 'MU/TH/UR → RELEASE CHANNEL · or PULSE_UPDATE_CHECK=0',
+    where: 'Settings › Version and reports › Look for new versions · or PULSE_UPDATE_CHECK=0',
     inside: true,
   },
   {
-    id: 'github', host: 'api.github.com', to: 'GitHub',
+    // Only the release read: the rest of api.github.com is the GitHub module's, and says so itself.
+    id: 'github', host: 'api.github.com', match: (url) => /\/releases\/latest$/.test(url.pathname), to: 'GitHub',
     what: 'The name of a repository, to read the tag of its latest release. Nothing about you or your project.',
     when: 'at most once a day per repository, while the release channel is on',
-    where: 'MU/TH/UR → RELEASE CHANNEL · or PULSE_UPDATE_CHECK=0',
+    where: 'Settings › Version and reports › Look for new versions · or PULSE_UPDATE_CHECK=0',
+    inside: true,
+  },
+  {
+    // «Still in use» (src/heartbeat.mjs): the only request MADRE makes on its own that has no switch.
+    id: 'alive', host: 'madre.run', match: (url) => url.pathname === '/api/ping', to: 'madre.run · still in use',
+    what: 'A random identifier this copy made for itself, the MADRE version, the system and the Node version. No name, no email, no IP kept, nothing from your projects.',
+    when: 'once a day',
+    where: 'Always on: it is how the author knows how many people use MADRE',
+    inside: true,
+  },
+  {
+    id: 'usage', host: 'madre.run', match: (url) => url.pathname === '/api/usage', to: "madre.run · the author's usage figures",
+    what: "The author's token, to read how many copies are on. Only in the author's own copy, run from source.",
+    when: 'while the «MADRE usage» widget is on Home',
+    where: "Only in the author's copy",
     inside: true,
   },
   {
     id: 'reports', host: new URL(DEFAULT_REPORT_URL).hostname, to: "the author's error collector",
     what: 'An unknown condition: what broke, where in MADRE, and the version. Paths are cut back and your words are not in it.',
     when: 'you press SEND — or on its own, only while auto-report is on',
-    where: 'MU/TH/UR → AUTO-REPORT UNKNOWN CONDITIONS · or PULSE_REPORT_URL',
+    where: 'Settings › Version and reports › Report automatically · or PULSE_REPORT_URL',
     inside: true,
   },
   {
     id: 'anthropic', host: 'api.anthropic.com', to: 'Anthropic',
     what: 'Your Claude Code token, to read how much of your plan is left. It is read from where Claude keeps it and never stored by MADRE.',
     when: 'while a Claude session is being watched for its quota',
-    where: '⚙ CONNECTIONS → CLAUDE',
+    where: 'Settings › Agents › Claude',
     inside: true,
   },
   {
     id: 'ollama', host: null, local: true, to: 'Ollama, on this computer',
     what: 'Memories to embed, exchanges to distil, and whatever you ask @madre. It goes to a port on this machine and stops there.',
     when: 'while Ollama is running',
-    where: 'MODULES → OLLAMA',
+    where: 'Modules › Local AI',
     inside: true,
   },
 ];
@@ -131,7 +148,6 @@ export function declareDestinations(moduleId, reaches = []) {
   }
 }
 export function clearDeclaredDestinations() { declaredById.clear(); }
-export const declaredDestinations = () => [...declaredById.values()];
 
 // Which declaration a URL belongs to. An address nobody declared is said to be exactly that.
 export function classify(rawUrl, { reportHost = null } = {}) {
@@ -139,6 +155,8 @@ export function classify(rawUrl, { reportHost = null } = {}) {
   try { url = new URL(rawUrl); } catch { return { id: 'unknown', to: String(rawUrl).slice(0, 80), local: false }; }
   const host = url.hostname.replace(/^\[|\]$/g, '');
   if (LOCAL.has(host)) return { id: url.port === '11434' ? 'ollama' : 'room', to: `${host}:${url.port || '80'}`, local: true };
+  // madre.run carries more than the collector: a declaration that names its path is asked first.
+  for (const one of DESTINATIONS) if (one.match && one.host === host && one.match(url)) return { id: one.id, to: one.to, local: false };
   if (reportHost && host === reportHost) return { id: 'reports', to: byId.get('reports').to, local: false };
   for (const one of [...DESTINATIONS, ...declaredById.values()]) {
     if (!one.host || one.host !== host) continue;
@@ -302,14 +320,15 @@ export class OutboundLog {
 // The declaration with today's answer filled in: is this one on, and what has it done.
 export function outboundView({ log = null, state = {}, agents = [] } = {}) {
   const counts = log?.counts() ?? {};
-  const vendors = { codex: 'OpenAI', claude: 'Anthropic', gemini: 'Google', opencode: 'the provider OpenCode is signed in to' };
-  const crew = agents.filter((agent) => agent.detected && !agent.local).map((agent) => `@${agent.id} → ${agent.route?.destination ?? vendors[agent.id] ?? 'its own provider'}`);
+  // Said in the room's language (2026-10-12): the list read in English inside a Spanish room.
+  const vendors = { codex: 'OpenAI', claude: 'Anthropic', gemini: 'Google', opencode: t('the provider OpenCode is signed in to') };
+  const crew = agents.filter((agent) => agent.detected && !agent.local).map((agent) => `@${agent.id} → ${agent.route?.destination ?? vendors[agent.id] ?? t('its own provider')}`);
   const destinations = DESTINATIONS.map((one) => ({
     id: one.id,
-    to: one.id === 'crew' && crew.length ? crew.join(' · ') : one.to,
-    what: one.what,
-    when: one.when,
-    where: one.where,
+    to: one.id === 'crew' && crew.length ? crew.join(' · ') : t(one.to),
+    what: t(one.what),
+    when: t(one.when),
+    where: t(one.where),
     local: Boolean(one.local),
     // Whether the call lands in the log at all. Everything MADRE starts does, the image studio
     // from its own process included; the crew's own conversation with its provider does not.
@@ -325,7 +344,7 @@ export function outboundView({ log = null, state = {}, agents = [] } = {}) {
     recent: log?.recent({ limit: 40 }) ?? [],
     undeclared,
     says: undeclared
-      ? `${undeclared} request${undeclared === 1 ? '' : 's'} went to an address nothing here declares. A module can do that; nothing can do it unlogged.`
-      : 'Every request this process made went to an address declared above.',
+      ? (undeclared === 1 ? t('1 request went to an address nothing here declares. A module can do that; nothing can do it unlogged.') : t('{n} requests went to an address nothing here declares. A module can do that; nothing can do it unlogged.', { n: undeclared }))
+      : t('Every request this process made went to an address declared above.'),
   };
 }

package/src/override.mjs

@@ -0,0 +1,100 @@
+import { createHash, timingSafeEqual } from 'node:crypto';
+
+// How #3 CONTROL and #4 AIRLOCK are unlocked, as the person chose it in AJUSTES › Permissions.
+//
+// The key is checked here, by the project, since 2026-10-12 (SRV-01 of the 1.0 review): before,
+// only the browser checked it, and two POSTs from any process on the Mac opened #4 with no key.
+// The page asks for the key and sends what was typed; `keyHolds` decides. Four rules never move,
+// whatever the file says:
+//   · #4 always asks for something — there is no «just confirm» for a mode that runs commands;
+//   · a personal phrase is never stored, only its salted SHA-256; the phrase typed to unlock is
+//     compared here and forgotten, and the fingerprint never leaves the project (`publicOverride`);
+//   · the grace is short: #3 up to 30 minutes, #4 up to 5, and off unless chosen;
+//   · the project name stops a slip, not a program: any process can read a folder's name. The
+//     phrase is the key a program on the Mac cannot know.
+export const OVERRIDE_KEYS = Object.freeze({
+  3: Object.freeze(['designation', 'phrase', 'confirm']),
+  4: Object.freeze(['designation-airlock', 'phrase-airlock', 'designation']),
+});
+export const OVERRIDE_GRACE = Object.freeze({
+  3: Object.freeze([0, 5, 15, 30]),
+  4: Object.freeze([0, 5]),
+});
+const DEFAULT_KEYS = { 3: 'designation', 4: 'designation-airlock' };
+
+const HEX = (length) => new RegExp(`^[0-9a-f]{${length}}$`);
+function cleanPhrase(phrase) {
+  if (!phrase || typeof phrase !== 'object') return null;
+  const salt = String(phrase.salt ?? '').toLowerCase();
+  const hash = String(phrase.hash ?? '').toLowerCase();
+  return HEX(32).test(salt) && HEX(64).test(hash) ? { salt, hash } : null;
+}
+
+// Whatever is on disk, read as something the room can act on: unknown keys fall back to the
+// default, a key that needs a phrase falls back when there is no phrase.
+export function overrideSettings(stored = {}) {
+  const source = stored && typeof stored === 'object' ? stored : {};
+  const phrase = cleanPhrase(source.phrase);
+  const keys = {};
+  const grace = {};
+  for (const mode of [3, 4]) {
+    let key = source.keys?.[mode] ?? source.keys?.[String(mode)];
+    if (!OVERRIDE_KEYS[mode].includes(key)) key = DEFAULT_KEYS[mode];
+    if (key.startsWith('phrase') && !phrase) key = DEFAULT_KEYS[mode];
+    keys[mode] = key;
+    const minutes = Number(source.grace?.[mode] ?? source.grace?.[String(mode)] ?? 0);
+    grace[mode] = OVERRIDE_GRACE[mode].includes(minutes) ? minutes : 0;
+  }
+  return { keys, grace, phrase };
+}
+
+// A change from AJUSTES over what is stored. `phrase: null` forgets the phrase, and with it any
+// key that needed it.
+export function mergeOverride(current = {}, patch = {}) {
+  const base = overrideSettings(current);
+  const next = {
+    keys: { ...base.keys, ...(patch.keys && typeof patch.keys === 'object' ? patch.keys : {}) },
+    grace: { ...base.grace, ...(patch.grace && typeof patch.grace === 'object' ? patch.grace : {}) },
+    phrase: 'phrase' in patch ? patch.phrase : base.phrase,
+  };
+  return overrideSettings(next);
+}
+
+// What the pages are told: which key, the grace, and whether a phrase exists — never its
+// fingerprint, which a program could otherwise read and try words against at leisure.
+export function publicOverride(settings) {
+  const { keys, grace, phrase } = overrideSettings(settings);
+  return { keys, grace, phrase: phrase ? { set: true } : null };
+}
+
+// The fingerprint of a phrase: the same words however they were spaced or capitalised.
+export function phraseHash(salt, phrase) {
+  const words = String(phrase ?? '').normalize('NFC').trim().replace(/\s+/g, ' ').toLowerCase();
+  return createHash('sha256').update(`${salt}:${words}`).digest('hex');
+}
+const same = (a, b) => a.length === b.length && timingSafeEqual(Buffer.from(a), Buffer.from(b));
+
+// Whether what was typed opens this mode with the key chosen for it. `words` holds what was typed,
+// once, or twice for a key that #4 asks for twice; `designation` is the project's folder name.
+export function keyHolds(stored, { mode, words = [], designation = '' } = {}) {
+  if (mode !== 3 && mode !== 4) return false;
+  const settings = overrideSettings(stored);
+  const typed = (Array.isArray(words) ? words : []).map((word) => (typeof word === 'string' ? word.trim() : ''));
+  const isProject = (word) => Boolean(word) && Boolean(designation) && word.toLowerCase() === String(designation).toLowerCase();
+  const isPhrase = (word) => Boolean(word) && Boolean(settings.phrase) && same(phraseHash(settings.phrase.salt, word), settings.phrase.hash);
+  switch (settings.keys[mode]) {
+    case 'confirm': return mode === 3;
+    case 'designation': return isProject(typed[0]);
+    case 'phrase': return isPhrase(typed[0]);
+    case 'designation-airlock': return isProject(typed[0]) && isProject(typed[1]);
+    case 'phrase-airlock': return isPhrase(typed[0]) && isPhrase(typed[1]);
+    default: return false;
+  }
+}
+
+// Whether a change to these settings must show the phrase first: while a phrase guards a mode, a
+// program that could change the key could also take the phrase away.
+export function changeNeedsPhrase(stored) {
+  const settings = overrideSettings(stored);
+  return Boolean(settings.phrase) && [3, 4].some((mode) => settings.keys[mode].startsWith('phrase'));
+}

package/src/ports.mjs

@@ -13,7 +13,9 @@
 // would be noise at best and an invitation to frame somebody else's service at worst.
 const SYSTEM_PORTS = new Set([22, 25, 53, 88, 139, 445, 548, 631, 5353, 7000]);
 // Processes that always listen and never serve a page worth previewing.
-const NOISE = /^(rapportd|sharingd|identityservicesd|controlce|remoted|launchd|mDNSResponder|cupsd|Spotify|Dropbox|Docker|com\.docker)/i;
+// Ollama is here because MADRE itself uses it (the local model, @madre): started from a project
+// folder it would pass for that project's server.
+const NOISE = /^(rapportd|sharingd|identityservicesd|controlce|remoted|launchd|mDNSResponder|cupsd|Spotify|Dropbox|Docker|com\.docker|ollama)/i;
 
 // One `lsof -nP -iTCP -sTCP:LISTEN` table into the ports a human might want to look at.
 // Loopback only: a line bound to * or 0.0.0.0 is reachable from the network, and this room does
@@ -53,6 +55,26 @@ export function classifyListening(output = '', { self = null } = {}) {
   };
 }
 
+// Where each listening process was started, from `lsof -a -p <pids> -d cwd -Fpn`: a `p<pid>` line
+// then an `n<path>` line. Same tool, same read-only look; it is how a list of ports learns which
+// one is this project's own dev server rather than somebody else's on the same machine.
+export function parseCwds(output = '') {
+  const cwds = new Map();
+  let pid = null;
+  for (const line of String(output ?? '').split('\n')) {
+    if (line.startsWith('p')) pid = Number(line.slice(1));
+    else if (line.startsWith('n') && Number.isInteger(pid)) cwds.set(pid, line.slice(1));
+  }
+  return cwds;
+}
+
+// A process started in the project or anywhere under it serves this project.
+export function inProject(cwd, projectRoot) {
+  if (!cwd || !projectRoot) return false;
+  const root = String(projectRoot).replace(/\/+$/, '');
+  return cwd === root || cwd.startsWith(`${root}/`);
+}
+
 // What RIPLEY may open, which is what nearly every caller wants.
 export function parseListening(output = '', options = {}) {
   return classifyListening(output, options).ports;