@jossuealcala/madre 0.3.2 → 0.4.0

package/src/distiller.mjs

@@ -3,7 +3,7 @@
 // keeping for every later turn. Pure functions here; the room schedules and
 // invokes. Nothing in this file talks to a model.
 
-import { MEMORY_KINDS } from './memory.mjs';
+import { ABERRATION, MEMORY_KINDS } from './memory.mjs';
 
 // Cheapest first, by the models these CLIs run by default.
 // Ollama, when the room has it, is the cheapest of all: local and free.
@@ -42,11 +42,12 @@ export function distillPrompt({ entries, projectName = 'the project', existing =
     `- fact: a verified statement about the project or its environment that is not obvious from the code`,
     `- preference: how the human wants things done or said`,
     `- question: something left open that a later turn should not forget`,
+    `- aberration: a claim the exchanges themselves showed to be false. Only when it was refuted out loud: someone stated something about this project and someone else corrected it, or the exchanges proved it wrong. Put the false claim in "text" and what turned out to be true in "correction". Never guess, never file a disagreement of opinion, and never file something merely unverified.`,
     'Skip greetings, restatements, transient status, anything a reader of the code would see anyway, and anything the exchanges do not actually establish.',
     json
-      ? `Output one JSON object and nothing else: {"memories":[...]} with at most ${MAX_MEMORIES_PER_RUN} items, each {"kind":"decision|fact|preference|question","text":"one self-contained sentence in the language the room uses, at most ${MAX_MEMORY_CHARS} characters, naming files, agents and numbers exactly","sources":[sequence numbers it comes from]}. If nothing durable was said: {"memories":[]}`
+      ? `Output one JSON object and nothing else: {"memories":[...]} with at most ${MAX_MEMORIES_PER_RUN} items, each {"kind":"${MEMORY_KINDS.join('|')}","text":"one self-contained sentence in the language the room uses, at most ${MAX_MEMORY_CHARS} characters, naming files, agents and numbers exactly","correction":"only on an aberration: what is true instead","sources":[sequence numbers it comes from]}. If nothing durable was said: {"memories":[]}`
       : `Output only JSON lines, one object per memory, at most ${MAX_MEMORIES_PER_RUN}, nothing else:`,
-    json ? null : `{"kind":"decision|fact|preference|question","text":"one self-contained sentence in the language the room uses, at most ${MAX_MEMORY_CHARS} characters, naming files, agents and numbers exactly","sources":[sequence numbers it comes from]}`,
+    json ? null : `{"kind":"${MEMORY_KINDS.join('|')}","text":"one self-contained sentence in the language the room uses, at most ${MAX_MEMORY_CHARS} characters, naming files, agents and numbers exactly","correction":"only on an aberration: what is true instead","sources":[sequence numbers it comes from]}`,
     json ? null : 'If nothing durable was said, output exactly: NONE',
     known,
     '<exchanges>',
@@ -76,13 +77,19 @@ export function parseDistillation(text, { fromSequence, throughSequence } = {})
     if (!parsed || typeof parsed !== 'object') continue;
     const memoryText = String(parsed.text ?? '').replace(/\s+/g, ' ').trim();
     if (!memoryText) continue;
-    const kind = MEMORY_KINDS.includes(parsed.kind) ? parsed.kind : 'fact';
+    // An unknown kind used to be filed as a fact. That was harmless while every kind was
+    // knowledge; now the list has one that is not, and a typo would turn a hallucination into
+    // something the room believes. Anything unrecognised is dropped instead.
+    if (!MEMORY_KINDS.includes(parsed.kind)) continue;
+    const kind = parsed.kind;
     const inRange = (n) => Number.isInteger(n) && (fromSequence == null || n >= fromSequence) && (throughSequence == null || n <= throughSequence);
     const sources = (Array.isArray(parsed.sources) ? parsed.sources : []).map(Number).filter(inRange);
     const key = memoryText.toLowerCase();
     if (seen.has(key)) continue;
     seen.add(key);
-    memories.push({ kind, text: memoryText.length > MAX_MEMORY_CHARS ? `${memoryText.slice(0, MAX_MEMORY_CHARS - 1)}…` : memoryText, sources });
+    const clip = (value) => (value.length > MAX_MEMORY_CHARS ? `${value.slice(0, MAX_MEMORY_CHARS - 1)}…` : value);
+    const correction = kind === ABERRATION ? clip(String(parsed.correction ?? '').replace(/\s+/g, ' ').trim()) : '';
+    memories.push({ kind, text: clip(memoryText), sources, ...(correction ? { correction } : {}) });
     if (memories.length >= MAX_MEMORIES_PER_RUN) break;
   }
   return memories;

package/src/event-store.mjs

@@ -8,16 +8,22 @@ export class EventStore {
   #nextSequence = 1;
   #writeQueue = Promise.resolve();
   #lockDirectory;
+  #floor = 0;
 
-  constructor(file) {
+  // `floor` is the highest sequence the rest of the project has already used. A project keeps one
+  // numbering across all of its conversations, so #1411 means one exchange in this project and
+  // not one in each thread — the memory index, every citation and NOSTROMO all lean on that.
+  // Gaps in a single ledger are fine: sequences are an order, not a count.
+  constructor(file, { floor = 0 } = {}) {
     this.#file = file;
+    this.#floor = Number.isFinite(floor) ? floor : 0;
     this.#lockDirectory = `${file}.lock`;
   }
 
   async initialize() {
     await mkdir(dirname(this.#file), { recursive: true });
     const existing = await this.readAll();
-    this.#nextSequence = (existing.at(-1)?.sequence ?? 0) + 1;
+    this.#nextSequence = Math.max(existing.at(-1)?.sequence ?? 0, this.#floor) + 1;
     return this;
   }
 
@@ -85,14 +91,14 @@ export class EventStore {
         return async () => {
           try {
             const owner = JSON.parse(await readFile(ownerFile, 'utf8'));
-            if (owner.token === token) await rm(this.#lockDirectory, { recursive: true, force: true });
+            if (owner.token === token) await rm(this.#lockDirectory, { recursive: true, force: true, maxRetries: 6, retryDelay: 60 });
           } catch (error) {
             if (error.code !== 'ENOENT') throw error;
           }
         };
       } catch (error) {
         if (created) {
-          await rm(this.#lockDirectory, { recursive: true, force: true });
+          await rm(this.#lockDirectory, { recursive: true, force: true, maxRetries: 6, retryDelay: 60 });
           throw error;
         }
         if (error.code !== 'EEXIST') throw error;
@@ -102,7 +108,7 @@ export class EventStore {
             process.kill(owner.pid, 0);
           } catch (ownerError) {
             if (ownerError.code === 'ESRCH') {
-              await rm(this.#lockDirectory, { recursive: true, force: true });
+              await rm(this.#lockDirectory, { recursive: true, force: true, maxRetries: 6, retryDelay: 60 });
               continue;
             }
           }
@@ -110,7 +116,7 @@ export class EventStore {
           if (ownerError.code !== 'ENOENT' && !(ownerError instanceof SyntaxError)) throw ownerError;
           const lock = await stat(this.#lockDirectory).catch(() => null);
           if (lock && Date.now() - lock.mtimeMs > 10000) {
-            await rm(this.#lockDirectory, { recursive: true, force: true });
+            await rm(this.#lockDirectory, { recursive: true, force: true, maxRetries: 6, retryDelay: 60 });
             continue;
           }
         }
@@ -138,7 +144,7 @@ export class EventStore {
         const temp = `${this.#file}.rewrite-${process.pid}`;
         await writeFile(temp, next.map((event) => JSON.stringify(event)).join('\n') + (next.length ? '\n' : ''));
         await rename(temp, this.#file);
-        this.#nextSequence = (next.at(-1)?.sequence ?? 0) + 1;
+        this.#nextSequence = Math.max(next.at(-1)?.sequence ?? 0, this.#floor) + 1;
         return { total: next.length, changed };
       } finally {
         await release();
@@ -153,7 +159,7 @@ export class EventStore {
       const release = await this.#acquireLock();
       try {
         const existing = await this.#readAllUnlocked();
-        const sequence = (existing.at(-1)?.sequence ?? 0) + 1;
+        const sequence = Math.max(existing.at(-1)?.sequence ?? 0, this.#floor) + 1;
         const event = {
           id: randomUUID(),
           sequence,

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