@jossuealcala/madre 0.3.3 → 0.4.1

package/src/exam.mjs

@@ -0,0 +1,240 @@
+// The three tests that answer "is this room ready to be developed with?"
+//
+// The maturity reading counts what the archive is made of. It cannot tell you whether the archive
+// works, because nothing about a pile of notes says whether the right one comes back when it is
+// needed. Only a test says that, and a test is only worth running if it can fail.
+//
+//   1 · COVERAGE   — when this project asks its own questions, does the archive already hold the
+//                    answer? Real human messages from the ledger, recall run at the point each
+//                    one was asked, scored against the reply that was actually given.
+//   2 · CONSISTENCY — does the archive contradict itself? Contradictions EYECAT is still holding,
+//                    what has been taken out of circulation, and whether aberrations are being
+//                    filed more often lately or less.
+//   3 · MATCH      — does the local model, with this archive behind it, land where the frontier
+//                    CLI landed? Real questions from the ledger, asked again locally, compared
+//                    against the answer that was given at the time.
+//
+// What every one of them refuses to do is grade itself generously. Each reports how it measured
+// (meaning or words), how many cases it had, and the bar it used, because a number without those
+// three is a decoration.
+
+import { t } from './i18n.mjs';
+
+export const COVERAGE_SAMPLE = 30;
+export const COVERAGE_BAR = 0.55;      // cosine between the reply and the closest thing recalled
+export const COVERAGE_WORDS_BAR = 0.25;
+export const MATCH_SAMPLE = 12;        // a local model answering is slow; honesty about that beats a big number
+export const MATCH_BAR = 0.6;
+// Every text in one room is about the same handful of subjects, so any two pieces of it read as
+// similar to an embedder. Measured against a bar alone, the first run of coverage scored thirty
+// out of thirty — a test that cannot fail measures nothing. So each case is also measured against
+// a control: the same question scored against another case's material. To count, what the archive
+// actually handed over has to beat what it would have handed over for something else.
+export const CONTROL_MARGIN = 0.05;
+export const MIN_ASK = 40;             // shorter than this is "ok", "sí", "dale": nothing to answer
+export const PASS = { coverage: 0.7, match: 0.7 };
+
+const rare = (text) => new Set(String(text ?? '').toLowerCase().normalize('NFD').replace(/[̀-ͯ]/g, '').match(/[a-z0-9][a-z0-9_/.-]{3,}/g) ?? []);
+
+// How close two pieces of text are when there is nothing to embed them with. Not a semantic
+// score and never reported as one: the share of the answer's own uncommon words that were
+// already in front of the room.
+export function wordScore(reference, candidate) {
+  const want = rare(reference);
+  const have = rare(candidate);
+  if (!want.size || !have.size) return 0;
+  let shared = 0;
+  for (const word of want) if (have.has(word)) shared += 1;
+  return shared / want.size;
+}
+
+export function cosine(a, b) {
+  if (!a || !b || a.length !== b.length) return 0;
+  let dot = 0;
+  let left = 0;
+  let right = 0;
+  for (let i = 0; i < a.length; i += 1) { dot += a[i] * b[i]; left += a[i] * a[i]; right += b[i] * b[i]; }
+  return left && right ? dot / Math.sqrt(left * right) : 0;
+}
+
+// Every human message in the ledger that actually got an answer, oldest first. Ghost turns never
+// happened as far as the archive is concerned, and a one-word message has no answer to find.
+export function exchanges(events = [], { minAsk = MIN_ASK, local = ['madre'] } = {}) {
+  const asked = new Map();
+  const out = [];
+  for (const event of events) {
+    if (!event || event.ghost) continue;
+    const payload = event.payload ?? {};
+    if (event.type !== 'message.created') continue;
+    if (payload.role === 'user' && payload.sender === 'you') {
+      const text = String(payload.text ?? '').trim();
+      if (text.length >= minAsk && !text.startsWith('/')) asked.set(payload.messageId, { sequence: event.sequence, text, target: payload.target });
+      continue;
+    }
+    if (payload.role !== 'assistant') continue;
+    const parent = payload.parentMessageId ?? payload.replyTo ?? payload.inReplyTo ?? null;
+    const question = parent ? asked.get(parent) : null;
+    if (!question) continue;
+    const answer = String(payload.text ?? '').trim();
+    if (answer.length < minAsk) continue;
+    asked.delete(parent);
+    out.push({ sequence: question.sequence, answerSequence: event.sequence, asked: question.text, answered: answer, agent: payload.sender, local: local.includes(payload.sender) });
+  }
+  return out;
+}
+
+// The control partner for each case: far enough down the list that it is a different day and a
+// different subject, and deterministic so a run can be repeated.
+export const controlOf = (index, n) => (n > 1 ? (index + Math.floor(n / 2)) % n : 0);
+
+// A sample spread across the whole ledger rather than taken off the end: fifty questions from one
+// afternoon test one afternoon.
+export function spread(items, size) {
+  if (items.length <= size) return [...items];
+  const step = items.length / size;
+  return Array.from({ length: size }, (_, i) => items[Math.floor(i * step)]);
+}
+
+/* ---------- 1 · COVERAGE ---------- */
+
+// `recall(text, beforeSequence)` hands back what the room would have been given at that moment.
+// `embed(texts)` is optional; without it the scoring says so and uses words.
+export async function coverageExam({ events = [], recall, embed = null, sample = COVERAGE_SAMPLE, bar = null } = {}) {
+  const all = exchanges(events);
+  const cases = spread(all, sample);
+  if (!cases.length) return { id: 'coverage', ran: false, says: t('No exchange in this room is long enough to test with yet.') };
+  const found = [];
+  for (const one of cases) {
+    const held = await recall(one.asked, one.sequence);
+    found.push(held.map((item) => String(item ?? '')).filter(Boolean));
+  }
+  const method = embed ? 'meaning' : 'words';
+  const used = bar ?? (embed ? COVERAGE_BAR : COVERAGE_WORDS_BAR);
+  const scores = [];
+  const controls = [];
+  if (embed) {
+    // One batch for the answers and one for everything that was recalled, so a remote embedder
+    // is asked twice and not sixty times.
+    const flat = found.flat();
+    const vectors = await embed([...cases.map((one) => one.answered), ...flat]);
+    const answers = vectors.slice(0, cases.length);
+    const rest = vectors.slice(cases.length);
+    const sets = [];
+    let at = 0;
+    for (const items of found) { sets.push(rest.slice(at, at + items.length)); at += items.length; }
+    for (let i = 0; i < cases.length; i += 1) {
+      const best = (set) => set.reduce((top, vector) => Math.max(top, cosine(answers[i], vector)), 0);
+      scores.push(best(sets[i]));
+      controls.push(best(sets[controlOf(i, cases.length)]));
+    }
+  } else {
+    for (let i = 0; i < cases.length; i += 1) {
+      const best = (set) => set.reduce((top, text) => Math.max(top, wordScore(cases[i].answered, text)), 0);
+      scores.push(best(found[i]));
+      controls.push(best(found[controlOf(i, cases.length)]));
+    }
+  }
+  // To count, the archive must have handed over this answer's material, and material it would
+  // not have handed over for a different question. With a single case there is nothing to
+  // compare against, and the result says so rather than pretending otherwise.
+  const controlled = cases.length > 1;
+  const hit = scores.map((score, i) => score >= used && (!controlled || score > controls[i] + CONTROL_MARGIN));
+  const hits = hit.filter(Boolean).length;
+  const rate = Number((hits / cases.length).toFixed(3));
+  const mean = (list) => Number((list.reduce((sum, value) => sum + value, 0) / list.length).toFixed(3));
+  return {
+    id: 'coverage', ran: true, at: new Date().toISOString(), n: cases.length, hits, rate, method, bar: used,
+    mean: mean(scores), control: controlled ? mean(controls) : null,
+    passed: rate >= PASS.coverage,
+    says: t('{hits} of {n} questions this room actually asked had their answer already in the archive, matched by {method}{control}.', { hits, n: cases.length, method: t(method), control: controlled ? t(' and against a control') : '' }),
+  };
+}
+
+/* ---------- 2 · CONSISTENCY ---------- */
+
+// Pure. Contradictions still open, how much has been taken out of circulation, and whether the
+// room is filing aberrations more often lately than it used to.
+export function consistencyExam({ findings = [], notes = [], now = Date.now() } = {}) {
+  const standing = notes.filter((note) => note && note.kind !== 'aberration' && !note.refutedBy);
+  const refuted = notes.filter((note) => note && note.refutedBy).length;
+  const aberrations = notes.filter((note) => note && note.kind === 'aberration');
+  const open = findings.filter((finding) => !finding?.settled).length;
+  const times = aberrations.map((note) => Date.parse(note.created)).filter((at) => Number.isFinite(at)).sort((a, b) => a - b);
+  const written = notes.map((note) => Date.parse(note.created)).filter((at) => Number.isFinite(at)).sort((a, b) => a - b);
+  let trend = null;
+  if (written.length > 4 && times.length) {
+    const middle = written[Math.floor(written.length / 2)];
+    const before = times.filter((at) => at < middle).length;
+    const after = times.length - before;
+    trend = after === before ? 'level' : after < before ? 'falling' : 'rising';
+  }
+  const passed = open === 0 && trend !== 'rising';
+  return {
+    id: 'consistency', ran: true, at: new Date(now).toISOString(),
+    open, refuted, standing: standing.length, aberrations: aberrations.length, trend,
+    passed,
+    says: open
+      ? t('EYECAT is holding {n} contradictions nobody has settled.', { n: open })
+      : trend === 'rising'
+        ? t('Nothing is open, but aberrations are being filed more often lately than they used to be.')
+        : t('Nothing contradicts anything: {standing} notes stand, {refuted} were taken out of circulation.', { standing: standing.length, refuted }),
+  };
+}
+
+/* ---------- 3 · MATCH ---------- */
+
+// `ask(question)` is the local model with this archive behind it. `embed` is needed: comparing
+// two answers by their words rewards copying the question back.
+export async function matchExam({ events = [], ask, embed, sample = MATCH_SAMPLE, bar = MATCH_BAR, onProgress = () => {}, stop = () => false } = {}) {
+  if (!embed) return { id: 'match', ran: false, says: t('This test needs embeddings: two answers cannot be compared by their words alone.') };
+  const all = exchanges(events).filter((one) => !one.local);   // a model is not tested against itself
+  const cases = spread(all, sample);
+  if (!cases.length) return { id: 'match', ran: false, says: t('No question in this room was answered by an agent other than the local one yet.') };
+  const mine = [];
+  for (const [index, one] of cases.entries()) {
+    if (stop()) return { id: 'match', ran: false, stopped: true, says: t('Stopped after {index} of {n}.', { index, n: cases.length }) };
+    onProgress({ done: index, total: cases.length });
+    try { mine.push(String((await ask(one.asked)) ?? '')); } catch { mine.push(''); }
+  }
+  onProgress({ done: cases.length, total: cases.length });
+  const vectors = await embed([...cases.map((one) => one.answered), ...mine]);
+  const theirs = vectors.slice(0, cases.length);
+  const ours = vectors.slice(cases.length);
+  const scores = cases.map((_, i) => (mine[i] ? cosine(theirs[i], ours[i]) : 0));
+  // Same control as coverage: an answer that is merely about the same project as every other
+  // answer in the room has not landed anywhere.
+  const controlled = cases.length > 1;
+  const controls = cases.map((_, i) => (mine[i] && controlled ? cosine(ours[i], theirs[controlOf(i, cases.length)]) : 0));
+  const matched = scores.filter((score, i) => score >= bar && (!controlled || score > controls[i] + CONTROL_MARGIN)).length;
+  const rate = Number((matched / cases.length).toFixed(3));
+  const mean = (list) => Number((list.reduce((sum, value) => sum + value, 0) / list.length).toFixed(3));
+  return {
+    id: 'match', ran: true, at: new Date().toISOString(), n: cases.length, matched, rate, mean: mean(scores), control: controlled ? mean(controls) : null, bar,
+    passed: rate >= PASS.match,
+    says: t('On {matched} of {n} real questions the local model landed where the agent of the day landed{control}.', { matched, n: cases.length, control: controlled ? t(', and not merely in the same project') : '' }),
+  };
+}
+
+// A reading that was taken months ago is still read today, and the room may have changed its
+// language since. The numbers are what was measured; the sentence is only how they are said, so
+// it is said again, now, from the fields that were stored. A stored result that predates this
+// keeps whatever sentence it was written with.
+export function saysFor(result) {
+  if (!result?.ran) return result?.says ?? null;
+  if (result.id === 'coverage' && Number.isFinite(result.hits)) {
+    return t('{hits} of {n} questions this room actually asked had their answer already in the archive, matched by {method}{control}.',
+      { hits: result.hits, n: result.n, method: t(result.method ?? 'words'), control: result.control === null || result.control === undefined ? '' : t(' and against a control') });
+  }
+  if (result.id === 'match' && Number.isFinite(result.matched)) {
+    return t('On {matched} of {n} real questions the local model landed where the agent of the day landed{control}.',
+      { matched: result.matched, n: result.n, control: result.control === null || result.control === undefined ? '' : t(', and not merely in the same project') });
+  }
+  if (result.id === 'consistency' && Number.isFinite(result.open)) {
+    return result.open
+      ? t('EYECAT is holding {n} contradictions nobody has settled.', { n: result.open })
+      : result.trend === 'rising'
+        ? t('Nothing is open, but aberrations are being filed more often lately than they used to be.')
+        : t('Nothing contradicts anything: {standing} notes stand, {refuted} were taken out of circulation.', { standing: result.standing, refuted: result.refuted });
+  }
+  return result.says ?? null;
+}

package/src/extensions.mjs

@@ -8,7 +8,7 @@ export const EXTENSIONS = MODULES;
 export const AHP = moduleById('ahp');
 export const IMAGE_STUDIO = moduleById('image-studio');
 export const GIT_PULSE = moduleById('git-pulse');
-export const ASHCODE = moduleById('ashcode');
+export const ASH = moduleById('ash');
 export const RIPLEY = moduleById('ripley');
 export const OLLAMA = moduleById('ollama');
 export const extensionById = moduleById;
@@ -26,9 +26,10 @@ export async function listExtensions({ projectRoot, agents = [], config = {}, im
 
 // Runs one installer inside the project, streaming output lines. `runner`
 // lets tests substitute the real installer with a local script.
+// `npm` and other Node CLIs are .cmd shims on Windows, which cannot be spawned directly.
 export function runInstaller({ command, args, projectRoot, onLine, timeoutMs = 600000, heartbeatMs = 8000, env = process.env }) {
   return new Promise((resolve) => {
-    const child = spawn(command, args, { cwd: projectRoot, env: { ...env, NO_COLOR: '1', CI: '1' }, stdio: ['ignore', 'pipe', 'pipe'] });
+    const child = spawn(command, args, { cwd: projectRoot, env: { ...env, NO_COLOR: '1', CI: '1' }, stdio: ['ignore', 'pipe', 'pipe'], shell: process.platform === 'win32', windowsHide: true });
     const started = Date.now();
     let lastOutput = started;
     // Installers go quiet for long stretches (npm install, git status); say so.

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;
+  });
+}