@jossuealcala/madre 0.3.3 → 0.4.0

package/src/eyecat-watch.mjs

@@ -0,0 +1,100 @@
+// EYECAT, as the room runs it. The judgement lives in eyecat.mjs; this schedules it, picks who
+// may answer, and puts what comes back in front of the human.
+//
+// It is not a module and not part of the room. It watches from outside, the way the error
+// sentinel does: it subscribes to the ledger, it never takes a turn, it writes no file and it
+// holds no permission. Nothing an agent says can reach it, and nothing it decides is final.
+// What it produces is a question for a person, never an entry in the archive.
+
+import { suspectPairs, unsupportedNotes, judgeFor, verdictPrompt, parseVerdict } from './eyecat.mjs';
+
+export const EYECAT_MAX_PER_SWEEP = 3;      // a ceiling, so a large archive cannot run up a bill
+export const EYECAT_FLOOR = 0.72;           // how close two notes must be to count as the same subject
+export const EYECAT_MIN_CONFIDENCE = 0.5;   // below this a verdict is not worth a person's attention
+
+export class Eyecat {
+  #deps;
+  #settled = new Set();
+  #open = new Map();
+  #running = false;
+
+  constructor(deps) { this.#deps = deps; }
+
+  settings() { return { enabled: this.#deps.enabled?.() !== false, floor: EYECAT_FLOOR, maxPerSweep: EYECAT_MAX_PER_SWEEP }; }
+  findings() { return [...this.#open.values()].sort((a, b) => (b.confidence ?? 0) - (a.confidence ?? 0)); }
+
+  // What a person already decided, replayed from the ledger so a restart does not ask twice.
+  seed(events = []) {
+    for (const event of events) {
+      if (event?.type === 'eyecat.flagged' && event.payload?.key) this.#open.set(event.payload.key, event.payload);
+      if (event?.type === 'eyecat.settled' && event.payload?.key) { this.#settled.add(event.payload.key); this.#open.delete(event.payload.key); }
+    }
+  }
+
+  // The room only ever distils between turns, so this is already out of band: no agent is
+  // waiting on it and none of them will see the answer.
+  async observe(event) {
+    if (event?.type !== 'memory.distilled') return null;
+    return this.sweep({ reason: 'distilled' }).catch(() => null);
+  }
+
+  settle(key, { verdict = 'dismissed' } = {}) {
+    if (!this.#open.has(key) && this.#settled.has(key)) return null;
+    const finding = this.#open.get(key) ?? { key };
+    this.#settled.add(key);
+    this.#open.delete(key);
+    return { ...finding, settledAs: verdict };
+  }
+
+  async sweep({ reason = 'asked' } = {}) {
+    if (this.#running || this.#deps.enabled?.() === false) return null;
+    const research = this.#deps.research?.();
+    if (!research?.memories?.length) return null;
+    this.#running = true;
+    try {
+      const skip = new Set([...this.#settled, ...this.#open.keys()]);
+      const candidates = [
+        ...suspectPairs(research.links ?? [], research.memories, { floor: EYECAT_FLOOR, settled: skip }),
+        ...unsupportedNotes(research.memories, this.#deps.entriesFor?.(research.memories) ?? [], { settled: skip }),
+      ].slice(0, EYECAT_MAX_PER_SWEEP);
+      const raised = [];
+      for (const candidate of candidates) {
+        const finding = await this.#judge(candidate, reason).catch(() => null);
+        if (finding) raised.push(finding);
+      }
+      return raised.length ? raised : null;
+    } finally {
+      this.#running = false;
+    }
+  }
+
+  async #judge(candidate, reason) {
+    const judge = judgeFor(candidate, this.#deps.bench?.() ?? {});
+    // With nobody impartial free, the candidate is left alone rather than handed to an agent
+    // with a stake in the answer. It will come round again on the next sweep.
+    if (!judge) return null;
+    const invoke = this.#deps.bench?.().invokers?.[judge.adapter];
+    if (!invoke) return null;
+    const cited = candidate.kind === 'unsupported' ? (this.#deps.entriesFor?.([candidate.claim]) ?? []).filter((entry) => candidate.cites.includes(entry.sequence)).map((entry) => entry.text) : [];
+    const answer = await invoke({ prompt: verdictPrompt({ ...candidate, citedText: cited }, { json: judge.local === true }), json: judge.local === true });
+    const verdict = parseVerdict(String(answer ?? ''), candidate);
+    if (!verdict || verdict.verdict !== 'contradiction') return null;
+    if (verdict.confidence !== null && verdict.confidence < EYECAT_MIN_CONFIDENCE) return null;
+    const accused = candidate.kind === 'unsupported' ? candidate.claim : (verdict.accused === candidate.against?.id ? candidate.against : candidate.claim);
+    const finding = {
+      key: candidate.key,
+      kind: candidate.kind,
+      reason,
+      judge: judge.id,
+      signals: candidate.signals ?? [],
+      confidence: verdict.confidence,
+      correction: verdict.correction || null,
+      claim: { id: accused.id, text: accused.text, kind: accused.kind, agent: accused.agent },
+      against: candidate.against && candidate.against.id !== accused.id ? { id: candidate.against.id, text: candidate.against.text } : null,
+      at: new Date().toISOString(),
+    };
+    this.#open.set(finding.key, finding);
+    await this.#deps.emit('eyecat.flagged', finding);
+    return finding;
+  }
+}

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/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'] },