@jossuealcala/madre 0.3.2 → 0.4.0

package/src/eyecat.mjs

@@ -0,0 +1,169 @@
+// EYECAT: the watcher that asks whether the room still believes what it wrote down.
+//
+// Pure functions here. Nothing in this file talks to a model, reads a file or touches the room;
+// the server schedules it and hands it what it needs, the way it does with the distiller.
+//
+// What it watches for is not error but drift. Two notes that are about the same thing and cannot
+// both be true; a note whose own citations do not say what it says. Either one quietly moves the
+// project's context away from what was actually settled, and by the time a person notices, every
+// turn since has been built on it.
+//
+// Independence is the whole design. A model that ratifies its own claim is worth nothing here,
+// so a claim is never judged by whoever wrote it, nor by whoever wrote what it clashes with.
+// The judge is given the two statements and nothing else: no transcript, no project history and
+// no names, so it cannot be told who to believe and cannot be argued with. It runs after the
+// turn, out of band, so no agent can address it or see its verdict.
+
+const NEGATORS = /\b(no|not|never|non|sin|nunca|ningun[ao]?|jamas|isn't|aren't|doesn't|don't|won't|cannot|can't)\b/gi;
+const ORDERINGS = [['before', 'after'], ['antes', 'despues'], ['first', 'last'], ['primero', 'ultimo'], ['above', 'below'], ['enabled', 'disabled'], ['on', 'off'], ['encendido', 'apagado']];
+
+const fold = (text) => String(text ?? '').toLowerCase().normalize('NFKD').replace(/[̀-ͯ]/g, '');
+const words = (text) => fold(text).match(/[a-z0-9][a-z0-9_./:-]*/g) ?? [];
+// Terms worth comparing: the ones that carry meaning rather than grammar.
+const TRIVIAL = new Set(['the', 'a', 'an', 'and', 'or', 'of', 'to', 'in', 'on', 'for', 'is', 'are', 'was', 'were', 'be', 'it', 'its', 'this', 'that', 'with', 'by', 'at', 'as', 'from', 'el', 'la', 'los', 'las', 'de', 'del', 'y', 'o', 'en', 'un', 'una', 'que', 'se', 'su', 'es', 'son', 'por', 'para', 'con', 'al', 'lo']);
+const meaningful = (text) => new Set(words(text).filter((word) => word.length > 2 && !TRIVIAL.has(word)));
+
+const countNegations = (text) => (fold(text).match(NEGATORS) ?? []).length;
+const numbersIn = (text) => (fold(text).match(/\b\d+(?:\.\d+)?\b/g) ?? []);
+// Things a project is specific about: paths, flags, dotted names, ports.
+const identifiersIn = (text) => (fold(text).match(/\b[a-z0-9_-]+(?:[./][a-z0-9_.-]+)+\b|--[a-z][a-z0-9-]*/g) ?? []);
+
+// Why two statements about the same thing might not both be true. Each signal is a cheap,
+// deterministic reason to look closer; none of them is a verdict.
+export function contradictionSignals(a, b) {
+  const signals = [];
+  if (countNegations(a) !== countNegations(b)) signals.push('negation');
+  const foldedA = fold(a);
+  const foldedB = fold(b);
+  for (const [one, other] of ORDERINGS) {
+    const hasA = new RegExp(`\\b${one}\\b`).test(foldedA) && !new RegExp(`\\b${other}\\b`).test(foldedA);
+    const hasB = new RegExp(`\\b${other}\\b`).test(foldedB) && !new RegExp(`\\b${one}\\b`).test(foldedB);
+    const flipped = new RegExp(`\\b${other}\\b`).test(foldedA) && new RegExp(`\\b${one}\\b`).test(foldedB);
+    if ((hasA && hasB) || flipped) { signals.push('order'); break; }
+  }
+  const [numbersA, numbersB] = [numbersIn(a), numbersIn(b)];
+  if (numbersA.length && numbersB.length && numbersA.join() !== numbersB.join()) signals.push('number');
+  const [idsA, idsB] = [identifiersIn(a), identifiersIn(b)];
+  if (idsA.length && idsB.length && !idsA.some((id) => idsB.includes(id))) signals.push('identifier');
+  return signals;
+}
+
+// Pairs worth a second look. The links are already computed for the constellation: a link says
+// two notes are about the same thing. EYECAT asks the next question, whether they agree, and
+// only where something cheap says they might not.
+export function suspectPairs(links, notes, { floor = 0.72, settled = new Set() } = {}) {
+  const byId = new Map(notes.map((note) => [note.id, note]));
+  const found = [];
+  for (const link of links ?? []) {
+    if ((link.weight ?? 0) < floor) continue;
+    const a = byId.get(link.a);
+    const b = byId.get(link.b);
+    if (!a || !b) continue;
+    // A note already taken out of circulation is not news, and neither is a pair a person settled.
+    if (a.kind === 'aberration' || b.kind === 'aberration' || a.refutedBy || b.refutedBy) continue;
+    const key = pairKey(a.id, b.id);
+    if (settled.has(key)) continue;
+    const signals = contradictionSignals(a.text, b.text);
+    if (!signals.length) continue;
+    // The newer of the two is the one on trial: drift moves forward, so the later claim is the
+    // one that changed what the project had settled.
+    const [older, newer] = a.id <= b.id ? [a, b] : [b, a];
+    found.push({ key, kind: 'contradiction', claim: newer, against: older, weight: link.weight, signals });
+  }
+  return found.sort((x, y) => y.signals.length - x.signals.length || y.weight - x.weight);
+}
+
+// A note is supposed to come from the exchanges it cites. When almost none of what makes it
+// distinctive appears in any of them, either it was invented or it was distilled from somewhere
+// it does not name, and both are worth asking about.
+export function unsupportedNotes(notes, entries, { share = 0.2, settled = new Set() } = {}) {
+  const text = new Map((entries ?? []).map((entry) => [entry.sequence, entry.text ?? '']));
+  const found = [];
+  for (const note of notes ?? []) {
+    if (note.kind === 'aberration' || note.refutedBy) continue;
+    if (note.origin && note.origin !== 'distilled') continue;   // a person's own note cites nothing
+    const cites = (note.sources ?? []).filter((sequence) => text.has(sequence));
+    if (!cites.length) continue;
+    const key = `note:${note.id}`;
+    if (settled.has(key)) continue;
+    const terms = meaningful(note.text);
+    if (terms.size < 3) continue;
+    const backing = meaningful(cites.map((sequence) => text.get(sequence)).join(' '));
+    let held = 0;
+    for (const term of terms) if (backing.has(term)) held += 1;
+    const support = held / terms.size;
+    if (support >= share) continue;
+    found.push({ key, kind: 'unsupported', claim: note, against: null, support, cites });
+  }
+  return found.sort((a, b) => a.support - b.support);
+}
+
+export const pairKey = (a, b) => `pair:${Math.min(a, b)}:${Math.max(a, b)}`;
+
+// Who may judge. Never whoever wrote the claim, never whoever wrote what it clashes with: a
+// model that ratifies its own work is worth nothing here. The local model comes first because it
+// is free and because it owes nothing to any of the accounts in the room.
+export const EYECAT_ORDER = ['ollama', 'gemini', 'opencode', 'codex', 'claude'];
+export function judgeFor(candidate, { agents = [], invokers = {}, busy = new Set(), benched = new Set() } = {}) {
+  const conflicted = new Set([candidate?.claim?.agent, candidate?.against?.agent].filter(Boolean));
+  const usable = agents.filter((agent) => agent.detected && agent.ready && !busy.has(agent.id) && !benched.has(agent.id) && invokers[agent.adapter]);
+  const impartial = usable.filter((agent) => !conflicted.has(agent.id));
+  for (const id of EYECAT_ORDER) {
+    const found = impartial.find((agent) => agent.id === id);
+    if (found) return found;
+  }
+  return impartial[0] ?? null;
+}
+
+// The question, with everything stripped that could tell the judge what to answer: no transcript,
+// no project history, no names and no order of authority. Two statements, one question.
+export function verdictPrompt(candidate, { json = false } = {}) {
+  const shape = '{"verdict":"contradiction|agreement|unrelated","wrong":"a|b|unknown","correction":"one sentence with what is actually true, or an empty string","confidence":0.0}';
+  if (candidate.kind === 'unsupported') {
+    return [
+      'You are a reviewer. You are given a statement recorded about a software project, and the exchanges it claims to come from. Nothing else is known about either.',
+      'Decide whether those exchanges actually establish the statement.',
+      'Answer "contradiction" if they say something else, "agreement" if they establish it, "unrelated" if they neither establish nor deny it.',
+      `Output one JSON object and nothing else: ${shape}. Here "a" is the statement.`,
+      '<statement>', candidate.claim.text, '</statement>',
+      '<cited>', ...(candidate.citedText ?? []), '</cited>',
+    ].filter(Boolean).join('\n');
+  }
+  return [
+    'You are a reviewer. You are given two statements recorded as true about the same software project, and nothing else.',
+    'You do not know who wrote either one, they carry no authority, and neither is more likely to be right because of where it appears.',
+    'Decide whether both can be true at the same time.',
+    'Answer "contradiction" only if believing one means the other is false. Answer "agreement" if both can stand. Answer "unrelated" if they are not about the same thing after all.',
+    `Output one JSON object and nothing else: ${shape}`,
+    '<a>', candidate.against?.text ?? '', '</a>',
+    '<b>', candidate.claim.text, '</b>',
+  ].join('\n');
+}
+
+const VERDICTS = ['contradiction', 'agreement', 'unrelated'];
+
+// Whatever came back, only a well-formed verdict survives. Anything else is "no answer", which
+// leaves the candidate where it was: pending, for a person to look at.
+export function parseVerdict(text, candidate = null) {
+  const raw = String(text ?? '');
+  const start = raw.indexOf('{');
+  const end = raw.lastIndexOf('}');
+  if (start < 0 || end <= start) return null;
+  let parsed;
+  try { parsed = JSON.parse(raw.slice(start, end + 1)); } catch { return null; }
+  if (!parsed || typeof parsed !== 'object') return null;
+  const verdict = VERDICTS.includes(parsed.verdict) ? parsed.verdict : null;
+  if (!verdict) return null;
+  const wrong = ['a', 'b'].includes(parsed.wrong) ? parsed.wrong : 'unknown';
+  const confidence = Number.isFinite(parsed.confidence) ? Math.min(1, Math.max(0, Number(parsed.confidence))) : null;
+  const correction = String(parsed.correction ?? '').replace(/\s+/g, ' ').trim().slice(0, 240);
+  // Which of the two the judge says is wrong, resolved back to a note. "a" is what was already
+  // there, "b" is the newer claim; a judge that will not choose leaves it to the person.
+  let accused = null;
+  if (candidate && verdict === 'contradiction') {
+    if (candidate.kind === 'unsupported') accused = candidate.claim;
+    else if (wrong === 'a') accused = candidate.against;
+    else if (wrong === 'b') accused = candidate.claim;
+  }
+  return { verdict, wrong, confidence, correction, accused: accused?.id ?? null };
+}

package/src/i18n.mjs

@@ -0,0 +1,47 @@
+// The room's language, on this side of the wire.
+//
+// The catalogue is the page's: public/es.js, one file for the whole product, because a sentence
+// that appears in a card and in a toast should not be translated twice and drift. What differs
+// is only where the choice comes from — here it is ~/.pulse/config.json, read once when the room
+// opens and again whenever it is changed — and what must never go through it:
+//
+//   · The prompt the agents read. It is English on purpose; see src/room/prompt.mjs.
+//   · Anything written INTO the ledger. Those lines are the record of what happened, in the
+//     language they happened in; translating the past is not translating, it is rewriting.
+//
+// So this is for text the server COMPUTES for a screen: what a module is, what it would create,
+// what a reading means. Same rule as the page: the key is the English sentence, and a sentence
+// nobody has translated comes back in English, whole.
+
+import { ES } from '../public/es.js';
+
+const CATALOGUES = { es: ES, en: {} };
+let current = 'es';
+
+export const language = () => current;
+export function setLanguage(id) {
+  current = id === 'en' ? 'en' : 'es';
+  return current;
+}
+
+export function t(text, vars = null) {
+  if (typeof text !== 'string' || !text) return text;
+  const said = CATALOGUES[current]?.[text] ?? text;
+  if (!vars) return said;
+  return said.replace(/\{(\w+)\}/g, (whole, name) => (Object.hasOwn(vars, name) ? String(vars[name]) : whole));
+}
+
+// A card, a list, a note: whatever a screen is handed, with only the fields that are prose put
+// through the catalogue. Everything else — ids, versions, paths, commands — is left alone,
+// because those are not sentences and a translated id is a bug.
+const PROSE = new Set(['summary', 'detail', 'note', 'says', 'brief', 'what', 'when', 'where', 'why', 'hint', 'title', 'label', 'remedy', 'diagnosis', 'creates', 'requires']);
+
+export function translate(value, key = null) {
+  if (Array.isArray(value)) return value.map((one) => translate(one, key));
+  if (value && typeof value === 'object') {
+    const out = {};
+    for (const [name, inner] of Object.entries(value)) out[name] = translate(inner, name);
+    return out;
+  }
+  return typeof value === 'string' && key && PROSE.has(key) ? t(value) : value;
+}

package/src/image-studio.mjs

@@ -18,6 +18,8 @@ export function imageStudioFor({ enabled, model, outDir, env = process.env }) {
       PULSE_IMAGE_MODEL: model ?? 'gemini-2.5-flash-image',
       ...(env.GEMINI_API_KEY ? { GEMINI_API_KEY: env.GEMINI_API_KEY } : {}),
       ...(env.PULSE_IMAGE_FAKE ? { PULSE_IMAGE_FAKE: env.PULSE_IMAGE_FAKE } : {}),
+      // So the one request that carries a prompt to Google lands in the same log as the rest.
+      ...(env.PULSE_OUTBOUND_LOG ? { PULSE_OUTBOUND_LOG: env.PULSE_OUTBOUND_LOG } : {}),
     },
   };
 }

package/src/launch.mjs

@@ -0,0 +1,61 @@
+// What is shown of a command, and what is never shown.
+//
+// THE LAUNCH floor in the core prints the exact command MADRE would run, because a person who is
+// handing their codebase to an agent deserves to read the line rather than trust a description of
+// it. But a command line is not only a command line: adapters pass MCP server settings inline, and
+// a server's environment is where keys live. A module somebody installs tomorrow can add one.
+//
+// So the arguments are shown whole except for environment VALUES, which are replaced everywhere
+// they appear, whatever shape the adapter wrote them in. The names stay — knowing that
+// GEMINI_API_KEY is set is the useful half, and the other half belongs in the keychain, not on a
+// screen somebody may be sharing.
+//
+// This runs over what the adapters' own arg builders produced, so the core can never print a
+// value the adapters did not print themselves — and cannot drift from them either.
+
+export const HIDDEN = '<set for this turn, not shown>';
+
+// Anything named like a credential has its value hidden even outside an env block.
+const SECRETISH = /(TOKEN|KEY|SECRET|PASSWORD|PASSWD|CREDENTIAL|AUTH|BEARER|SESSION)/i;
+
+// env objects anywhere in a parsed JSON argument, however deep an adapter nested them.
+function hideEnv(value) {
+  if (Array.isArray(value)) return value.map(hideEnv);
+  if (!value || typeof value !== 'object') return value;
+  const out = {};
+  for (const [key, inner] of Object.entries(value)) {
+    if (key === 'env' && inner && typeof inner === 'object' && !Array.isArray(inner)) {
+      out[key] = Object.fromEntries(Object.keys(inner).map((name) => [name, HIDDEN]));
+    } else out[key] = hideEnv(inner);
+  }
+  return out;
+}
+
+// `mcp_servers.<name>.env={ NAME = "value", … }`, which is how Codex takes them.
+const TOML_ENV = /^((?:[\w-]+\.)*env)=\{(.*)\}\s*$/s;
+const TOML_PAIR = /([\w.-]+)\s*=\s*("(?:[^"\\]|\\.)*"|'[^']*')/g;
+
+function hideTomlEnv(arg) {
+  const found = TOML_ENV.exec(arg);
+  if (!found) return null;
+  const body = found[2].replace(TOML_PAIR, (_, name) => `${name} = ${HIDDEN}`);
+  return `${found[1]}={${body}}`;
+}
+
+// `NAME=value` passed as one argument, when the name reads like a credential.
+const PLAIN = /^([A-Z][A-Z0-9_]*)=(.+)$/s;
+
+export function redactArgs(args = []) {
+  return args.map((arg) => {
+    if (typeof arg !== 'string') return arg;
+    const toml = hideTomlEnv(arg);
+    if (toml) return toml;
+    const plain = PLAIN.exec(arg);
+    if (plain && SECRETISH.test(plain[1])) return `${plain[1]}=${HIDDEN}`;
+    const trimmed = arg.trim();
+    if (trimmed.startsWith('{') && trimmed.endsWith('}')) {
+      try { return JSON.stringify(hideEnv(JSON.parse(trimmed))); } catch { /* not JSON after all: it is shown as the adapter wrote it */ }
+    }
+    return arg;
+  });
+}

package/src/lease.mjs

@@ -63,12 +63,14 @@ export function diffSnapshots(before, after, { relativeDir }) {
   return artifacts.sort((a, b) => a.path.localeCompare(b.path));
 }
 
-export function leaseInstructions({ outDir, agentId, scopes = { write: true, imageGen: agentId === 'codex' }, capable = null, imageStudio = null, control = false, create = false, scratchDir = null }) {
+export function leaseInstructions({ outDir, agentId, scopes = { write: true, imageGen: agentId === 'codex' }, capable = null, imageStudio = null, control = false, create = false, airlock = false, scratchDir = null }) {
   const canImage = Boolean(scopes.imageGen);
   const couldImage = capable ? Boolean(capable.imageGen?.capable) : canImage;
   const scratch = scratchDir ? `${outDir}/${scratchDir}` : null;
   return [
-    control
+    airlock
+      ? `AIRLOCK (#4): the human opened the airlock for you on this project at ${outDir}. Everything CONTROL allows, and you may run commands inside it: tests, builds, git commit and push, deploys with the CLIs and sessions already on this machine. Files are checkpointed and UNDO restores them; what leaves the machine (a push, a deploy, an API call) does not come back. Before anything leaves, state in one line exactly what goes out and where, then do it. Never print, copy or move secrets. Use git commands, never .git internals.`
+      : control
       ? `CONTROL (#3): the human put you in command of this project at ${outDir}. You may read, create and modify its files without asking, one change at a time, minimal and reversible. MADRE took a checkpoint before this turn; everything you change is listed to the human afterwards and can be undone in one click.`
       : create
         ? `CREATE (#2): the human allows you to create new files and folders anywhere in this project, at ${outDir}, where they belong by the project's own conventions (a page next to the other pages, a component with the components, a document with the documents). Create folders when the structure calls for it.${scratch ? ` If something has no natural place, put it in the scratch folder ${scratch}.` : ''}`
@@ -78,7 +80,7 @@ export function leaseInstructions({ outDir, agentId, scopes = { write: true, ima
       : create
         ? 'Do not modify, overwrite, rename or delete files that already exist: MADRE restores them after your turn and tells the human. If a change to an existing file is truly needed, say so and stop; the human can grant #3 CONTROL. Never touch .git, .pulse, .madre, .env files or credentials.'
         : 'Write every file you produce there (images, code, documents); paths elsewhere are denied.',
-    control ? 'End with a short list of the files you changed and why.' : create ? 'End with a short list of the files you created, with their paths, and why there.' : 'Reading the project stays allowed. Do not modify project files.',
+    airlock ? 'End with the commands you ran, what left the machine, and the files you changed.' : control ? 'End with a short list of the files you changed and why.' : create ? 'End with a short list of the files you created, with their paths, and why there.' : 'Reading the project stays allowed. Do not modify project files.',
     imageStudio ? `You can generate images with the MCP tool ${imageStudio.tool} (server ${imageStudio.name}): pass a detailed prompt and a file_name; it saves the PNG${scratch ? ` into ${scratch}` : ' into the lease directory'} and returns the path.`
       : canImage ? `You can generate images; save them${create ? ' where images live in this project, or in the scratch folder,' : ' into the lease directory'} with a descriptive file name.`
       : couldImage ? 'Image generation is switched off for this request; if asked for an image, say so and do not attempt it.'

package/src/maturity.mjs

@@ -0,0 +1,94 @@
+// How grown a room is, and how far from being worth training on.
+//
+// Pure functions. The room hands in what it has; nothing here reads a file or calls a model.
+//
+// This replaces a bar that filled toward three hundred. That number was a rule of thumb from
+// somebody else's paper, not a measurement of this room, and a corpus of three hundred pairs all
+// about the same afternoon teaches less than eighty that are not. What is measured here is what
+// can actually be counted about this archive, and each reading says plainly what would raise it.
+
+// How much of the whole each reading is worth. Volume counts, but it is one voice of six: a room
+// can be large and still be narrow, unjudged and lopsided.
+import { t } from './i18n.mjs';
+
+export const WEIGHTS = { volume: 0.2, coverage: 0.2, weave: 0.15, judgement: 0.2, balance: 0.15, upkeep: 0.1 };
+export const VOLUME_TARGET = 300;   // the usual floor for a small adapter, and nothing more than that
+
+const share = (part, whole) => (whole > 0 ? Math.min(1, Math.max(0, part / whole)) : 0);
+const round = (value) => Number(value.toFixed(3));
+
+// Six readings, each 0 to 1, each with the one thing that would raise it.
+export function maturity({ readiness = null, notes = [], links = [], stats = null } = {}) {
+  const standing = notes.filter((note) => note.kind !== 'aberration' && !note.refutedBy);
+  const pairs = Number(readiness?.pairs ?? 0);
+  const rated = Number(readiness?.good ?? 0) + Number(readiness?.bad ?? 0);
+  const turns = Number(readiness?.turns ?? 0) + Number(readiness?.delegated ?? 0);
+  const noteShare = pairs > 0 ? Number(readiness?.notes ?? 0) / pairs : 0;
+
+  const recalled = standing.filter((note) => Number(note.recalled ?? 0) > 0).length;
+  const linked = new Set(links.flatMap((link) => [link.a, link.b]));
+  const connected = standing.filter((note) => linked.has(note.id)).length;
+  const pending = Number(stats?.pending ?? 0);
+  const entries = Number(stats?.entries ?? 0);
+
+  const signals = [
+    {
+      id: 'volume', label: t('HOW MUCH THERE IS'),
+      value: round(share(pairs, VOLUME_TARGET)),
+      detail: t('{pairs} of about {target} exchanges worth training on', { pairs, target: VOLUME_TARGET }),
+      next: t('Use the room. Nothing else fills this.'),
+    },
+    {
+      id: 'coverage', label: t('HOW MUCH OF IT GETS USED'),
+      value: round(share(recalled, standing.length)),
+      detail: t('{recalled} of {total} memories have been reached for at least once', { recalled, total: standing.length }),
+      next: t('Memories nobody has needed may be noise, or may simply not have come up yet. Ask the room about older decisions and see which ones answer.'),
+    },
+    {
+      id: 'weave', label: t('HOW WOVEN IT IS'),
+      value: round(share(connected, standing.length)),
+      detail: t('{connected} of {total} memories share a subject with another', { connected, total: standing.length }),
+      next: t('An archive of unrelated notes is a list. Depth comes from returning to the same subjects.'),
+    },
+    {
+      id: 'judgement', label: t('HOW MUCH OF IT YOU JUDGED'),
+      // A tenth rated is enough to steer a small adapter; asking for all of it would never be met.
+      value: round(share(rated, Math.max(1, pairs * 0.1))),
+      detail: t('{rated} of {pairs} replies rated', { rated, pairs }),
+      next: t('Rate replies with the thumbs on a bubble. A corpus nobody judged teaches what the agents said, not what you approved.'),
+    },
+    {
+      id: 'balance', label: t('HOW MUCH OF IT IS REAL WORK'),
+      // Half recall pairs is healthy; a corpus that is mostly recall teaches recitation. A room
+      // with no corpus at all is not balanced, it is empty, and saying otherwise would show
+      // progress where there is none.
+      value: pairs > 0 ? round(1 - Math.min(1, Math.max(0, (noteShare - 0.5) / 0.5))) : 0,
+      detail: t('{share}% of the corpus is recall questions, {turns} exchanges are real work', { share: Math.round(noteShare * 100), turns }),
+      next: t('Recall pairs are made from notes and cost nothing, so they pile up. Work in the room to balance them.'),
+    },
+    {
+      id: 'upkeep', label: t('HOW CURRENT IT IS'),
+      value: round(entries > 0 ? 1 - share(pending, Math.max(1, entries * 0.15)) : 0),
+      detail: t('{pending} exchanges nobody has distilled yet, of {entries}', { pending, entries }),
+      next: t('The archivist catches up on its own. A backlog that never clears means it cannot run: check who is allowed to distil.'),
+    },
+  ];
+
+  const score = round(signals.reduce((sum, signal) => sum + signal.value * (WEIGHTS[signal.id] ?? 0), 0));
+  return { score, stage: stageOf(score), signals, weakest: [...signals].sort((a, b) => a.value - b.value)[0]?.id ?? null };
+}
+
+// What to call it. A name is not a measurement, but a number alone tells nobody whether to act.
+export const STAGES = [
+  { at: 0.85, id: 'mature', label: 'MATURE', says: 'Worth training on. Export and run the recipe.' },
+  { at: 0.6, id: 'working', label: 'WORKING', says: 'Usable, and it will be better for waiting.' },
+  { at: 0.35, id: 'forming', label: 'FORMING', says: 'It has a shape. Too thin to train on.' },
+  { at: 0.12, id: 'sparse', label: 'SPARSE', says: 'A few things remembered, little connecting them.' },
+  { at: 0, id: 'empty', label: 'EMPTY', says: 'Nothing has been distilled yet.' },
+];
+// The table holds the English, and the stage is said in the room's language when it is asked
+// for: this list is built when the file is imported, and the room learns its language after.
+export function stageOf(score) {
+  const stage = STAGES.find((one) => score >= one.at) ?? STAGES.at(-1);
+  return { ...stage, label: t(stage.label), says: t(stage.says) };
+}

package/src/mcp/image-server.mjs

@@ -17,6 +17,7 @@ import { execFile } from 'node:child_process';
 import { mkdir, writeFile, realpath } from 'node:fs/promises';
 import { basename, extname, join, resolve, sep } from 'node:path';
 import { promisify } from 'node:util';
+import { OutboundLog } from '../outbound.mjs';
 
 const execFileAsync = promisify(execFile);
 const SERVER_NAME = 'pulse-image';
@@ -62,6 +63,16 @@ export function explainGoogleError(status, body) {
   return { code: 'ERROR', message: message || `Google returned HTTP ${status}.` };
 }
 
+// The image studio runs in a process of its own, so it writes its own line into the room's
+// outbound log. Without this, the one request MADRE makes that carries somebody's words to
+// Google would be the one request the log could not see.
+let outboundLog = null;
+function outboundFetch(fetchImpl, file) {
+  if (!file) return fetchImpl;
+  outboundLog ??= new OutboundLog({ file });
+  return outboundLog.watch(fetchImpl);
+}
+
 export async function generateImage({ prompt, fileName, outDir, model = process.env.PULSE_IMAGE_MODEL || DEFAULT_MODEL, env = process.env, fetchImpl = fetch }) {
   if (!prompt || typeof prompt !== 'string') throw Object.assign(new Error('A text prompt is required.'), { code: 'INVALID' });
   const root = await realpath(outDir).catch(() => null);
@@ -76,7 +87,7 @@ export async function generateImage({ prompt, fileName, outDir, model = process.
   }
   const key = await resolveGeminiKey(env);
   if (!key) throw Object.assign(new Error('No Gemini API key: set GEMINI_API_KEY or sign in with the Gemini CLI (/auth → API key).'), { code: 'NO_KEY' });
-  const response = await fetchImpl(`https://generativelanguage.googleapis.com/v1beta/models/${encodeURIComponent(model)}:generateContent`, {
+  const response = await outboundFetch(fetchImpl, env.PULSE_OUTBOUND_LOG)(`https://generativelanguage.googleapis.com/v1beta/models/${encodeURIComponent(model)}:generateContent`, {
     method: 'POST',
     headers: { 'content-type': 'application/json', 'x-goog-api-key': key },
     body: JSON.stringify({ contents: [{ parts: [{ text: prompt }] }], generationConfig: { responseModalities: ['IMAGE'] } }),

package/src/mcp/memory-server.mjs

@@ -57,7 +57,7 @@ export const TOOLS = [
     name: 'memory_note',
     description: 'Save one durable memory of this room, ONLY when the human explicitly asks you to remember, note or save something (memories are otherwise distilled automatically; never save on your own initiative). One self-contained sentence, at most 240 characters, in the language the room uses, with the ledger sequences it comes from when you know them. Refused in a GHOST turn.',
     inputSchema: { type: 'object', properties: {
-      kind: { type: 'string', enum: MEMORY_KINDS, description: 'decision, fact, preference or question.' },
+      kind: { type: 'string', enum: MEMORY_KINDS, description: 'decision, fact, preference, question, or aberration for a claim this room established is false.' },
       text: { type: 'string', description: 'The memory, one sentence, names and numbers exact.' },
       sources: { type: 'array', items: { type: 'integer' }, description: 'Ledger sequences it comes from, if known.' },
     }, required: ['kind', 'text'] },