@jossuealcala/madre 1.0.1 → 1.0.3

package/src/config.mjs

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// MADRE · © 2026 Jossue Alcalá · GNU AGPL v3 with additional terms (Section 7): ADDITIONAL-TERMS.md
 import { randomUUID } from 'node:crypto';
 import { copyFile, mkdir, open, readFile, rename, rm, stat, writeFile } from 'node:fs/promises';
 import { homedir } from 'node:os';

package/src/conversation-context.mjs

@@ -1,3 +1,17 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// MADRE · © 2026 Jossue Alcalá · GNU AGPL v3 with additional terms (Section 7): ADDITIONAL-TERMS.md
+// What a command's output may weigh in the shared window, and which part of it. It used to be the
+// first 6000 characters: five outputs filled the 16 000 of the window, the request that asked for
+// them went out of it, and the agent lost the thread (2026-10-14). Now it is the start and the end
+// — a test run says what it is at the top and how it went at the bottom — and the agent that asked
+// gets the fuller output in a turn of its own (src/room/returns.mjs).
+const COMMAND_HEAD = 300;
+const COMMAND_TAIL = 900;
+function commandEnds(text) {
+  if (text.length <= COMMAND_HEAD + COMMAND_TAIL) return text;
+  return `${text.slice(0, COMMAND_HEAD)}\n… ${text.length - COMMAND_HEAD - COMMAND_TAIL} characters left out …\n${text.slice(-COMMAND_TAIL)}`;
+}
+
 export function messageEntry(event) {
   if (event.type === 'message.failed') {
     // Failures are part of the conversation: an orchestrator closing a plan
@@ -9,7 +23,7 @@ export function messageEntry(event) {
   if (event.type === 'command.output') {
     const { name, title, text } = event.payload;
     if (typeof text !== 'string' || !text.trim()) return null;
-    return { sequence: event.sequence, messageId: `${event.id}:command`, role: 'command', sender: `/${name}`, target: 'room', text: `${title}\n${text.trim()}`.slice(0, 6000) };
+    return { sequence: event.sequence, messageId: `${event.id}:command`, role: 'command', sender: `/${name}`, target: 'room', text: `${title}\n${commandEnds(text.trim())}` };
   }
   if (event.type !== 'message.created') return null;
   const { messageId, role, sender, target, text } = event.payload;

package/src/credentials.mjs

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// MADRE · © 2026 Jossue Alcalá · GNU AGPL v3 with additional terms (Section 7): ADDITIONAL-TERMS.md
 // Handing a provider key to a CLI that signs in from its own prompt.
 //
 // MADRE keeps its promise: it never stores a credential of its own. The key the human pastes is
@@ -36,6 +38,32 @@ export const OPENCODE_PROVIDERS = [
   { id: 'google', label: 'Google AI Studio', keyUrl: 'https://aistudio.google.com/app/apikey' },
 ];
 
+// The rest of the providers OpenCode knows (2026-10-14): its own catalogue, models.dev, which it
+// caches itself. Those a single key opens can be wired from MADRE; the ones that need an account
+// id, a region or a second secret stay with `opencode auth login`. Read only, never fetched.
+export const OPENCODE_FEATURED = ['anthropic', 'openai', 'google', 'openrouter', 'groq', 'deepseek', 'mistral', 'xai', 'togetherai', 'fireworks-ai', 'cerebras', 'perplexity', 'huggingface', 'deepinfra', 'moonshotai', 'zai', 'cohere', 'vercel'];
+export async function readOpenCodeCatalog({ home = homedir(), env = process.env } = {}) {
+  const raw = await readIfThere(join(env.XDG_CACHE_HOME || join(home, '.cache'), 'opencode', 'models.json'));
+  let data = {};
+  try { data = JSON.parse(raw ?? '{}') ?? {}; } catch { data = {}; }
+  if (!data || typeof data !== 'object' || Array.isArray(data)) return [];
+  const out = [];
+  for (const [id, one] of Object.entries(data)) {
+    if (!/^[\w.-]{1,60}$/.test(id) || !one || typeof one !== 'object' || !Array.isArray(one.env) || one.env.length !== 1) continue;
+    out.push({ id, label: typeof one.name === 'string' && one.name.trim() ? one.name.trim().slice(0, 60) : id, docUrl: typeof one.doc === 'string' && /^https:\/\//.test(one.doc) ? one.doc : null });
+  }
+  return out;
+}
+// Every provider a key can be pasted for: MADRE's own four first (their key pages), then the
+// catalogue's, each once, the popular ones marked.
+export async function openCodeKeyProviders({ home = homedir(), env = process.env } = {}) {
+  const catalog = await readOpenCodeCatalog({ home, env });
+  const byId = new Map(OPENCODE_PROVIDERS.map((one) => [one.id, { ...one, featured: true }]));
+  for (const one of catalog) if (!byId.has(one.id)) byId.set(one.id, { id: one.id, label: one.label, keyUrl: one.docUrl, featured: OPENCODE_FEATURED.includes(one.id) });
+  const rank = (one) => { const at = OPENCODE_FEATURED.indexOf(one.id); return at < 0 ? Infinity : at; };
+  return [...byId.values()].sort((a, b) => Number(b.featured) - Number(a.featured) || rank(a) - rank(b));
+}
+
 // What the room offers for each agent that cannot be signed in with a click.
 export function keyPlanFor(id) {
   if (id === 'claude') {
@@ -58,6 +86,9 @@ export function keyPlanFor(id) {
       writesTo: '~/.gemini/.env',
       note: 'The key is written where the Gemini CLI looks for it, readable only by you. MADRE keeps no copy.',
       providers: null,
+      // The way in, ahead of the Google account: Google refuses free personal accounts on this
+      // CLI (IneligibleTierError, 2026-10-17), and a key from AI Studio is what works for anyone.
+      first: true,
     };
   }
   if (id === 'opencode') {
@@ -140,7 +171,7 @@ async function applyClaudeKey(key, { home, probe }) {
 
 // ---- OpenCode: an entry in its auth.json, confirmed by asking `opencode auth list`.
 async function applyOpenCodeKey(key, { home, provider, executable, run }) {
-  const known = OPENCODE_PROVIDERS.some((item) => item.id === provider);
+  const known = typeof provider === 'string' ? (await openCodeKeyProviders({ home })).find((item) => item.id === provider) : null;
   if (!known) return { ok: false, error: 'Pick the provider this key belongs to.' };
   const file = join(home, '.local', 'share', 'opencode', 'auth.json');
   await mkdir(join(home, '.local', 'share', 'opencode'), { recursive: true });
@@ -153,8 +184,9 @@ async function applyOpenCodeKey(key, { home, provider, executable, run }) {
     await chmod(file, OWNER_ONLY).catch(() => {});
     // OpenCode itself is the judge: if its own listing does not show the provider, the shape
     // MADRE wrote is not the shape it reads, and nothing should be left behind.
-    const listed = await run(executable, ['auth', 'list']);
-    if (!new RegExp(provider, 'i').test(listed)) {
+    // It lists the provider by its name («Together AI»), sometimes by its id.
+    const listed = String(await run(executable, ['auth', 'list'])).toLowerCase();
+    if (!listed.includes(provider.toLowerCase()) && !listed.includes(String(known.label).toLowerCase())) {
       await restore(file, before);
       return { ok: false, error: `OpenCode does not list ${provider} after the key was written, so MADRE put the file back. Run \`opencode auth login\` in a terminal for this one.` };
     }

package/src/dataset.mjs

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// MADRE · © 2026 Jossue Alcalá · GNU AGPL v3 with additional terms (Section 7): ADDITIONAL-TERMS.md
 // The dataset behind MADRE AI: every exchange the room kept (never GHOST),
 // redacted, as chat pairs a small model can learn from, plus the distilled
 // notes. Written next to the room's ledger in the format mlx-lm and most
@@ -5,7 +7,7 @@
 // Export is the first step of roadmap 2c; training runs outside MADRE, on the
 // human's machine, from docs/training/.
 
-import { mkdir, writeFile } from 'node:fs/promises';
+import { mkdir, readFile, readdir, rm, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { redact } from './sentinel-errors.mjs';
 import { ABERRATION, VERDICTS, NEGATIVE_VERDICTS, POSITIVE_VERDICTS } from './memory.mjs';
@@ -119,6 +121,78 @@ export function pairsFromNotes(notes, { project = 'project', home, user, privacy
   }));
 }
 
+// D-S15 · what the Coordinator learns from the projects that let it. Each note of a linked project
+// becomes a pair that names its project — in the question, in the answer and in the citation — so
+// the model learns which project knows what and never blends two projects into one. The notes
+// arrive already cleaned by the project that served them; they are cleaned again here, by Salas.
+export function pairsFromLinked(corpora, { home, user, privacy = null } = {}) {
+  const clean = guard(privacy);
+  const pairs = [];
+  for (const corpus of corpora ?? []) {
+    const name = String(corpus?.name ?? corpus?.from ?? 'project');
+    for (const note of corpus?.notes ?? []) {
+      if (!note || typeof note.text !== 'string' || !note.text.trim() || note.kind === ABERRATION) continue;
+      const text = clean(redact(note.text, { home, user }));
+      const cite = `${name} #${note.fromSequence}${note.throughSequence && note.throughSequence !== note.fromSequence ? `–#${note.throughSequence}` : ''}`;
+      pairs.push({
+        kind: 'linked',
+        agent: 'madre',
+        from: corpus.from ?? null,
+        mode: 1,
+        sequence: Number.isInteger(note.throughSequence) ? note.throughSequence : 0,
+        at: note.created ?? null,
+        messages: [
+          { role: 'system', content: LINKED_SYSTEM },
+          { role: 'user', content: `What does the project "${name}" remember about this? Kind: ${note.kind}. Topic: ${text.split(/[.;:]/)[0].slice(0, 80)}` },
+          { role: 'assistant', content: `In ${name}: ${text} [${cite}]` },
+        ],
+      });
+    }
+    // D-S16: the project's canonical state, as a photo with its date. The date is in the question
+    // and in the answer, so the model learns «as of», never «now»: for today it asks the project.
+    const state = corpus?.state;
+    if (state?.project) {
+      const date = String(state.project.updatedAt ?? corpus.at ?? '').slice(0, 10) || 'an unknown date';
+      const say = (value) => clean(redact(String(value ?? ''), { home, user }));
+      const base = Number.isInteger(corpus.notes?.at(-1)?.throughSequence) ? corpus.notes.at(-1).throughSequence : 0;
+      const pair = (offset, question, answer) => pairs.push({ kind: 'linked', agent: 'madre', from: corpus.from ?? null, mode: 1, sequence: base + offset, at: state.project.updatedAt ?? null, messages: [{ role: 'system', content: LINKED_SYSTEM }, { role: 'user', content: question }, { role: 'assistant', content: answer }] });
+      const where = [state.project.objective && `the objective is ${say(state.project.objective)}`, state.project.phase && `the phase is ${say(state.project.phase)}`, state.project.nextAction && `the next action is ${say(state.project.nextAction)}`, state.project.blockers?.length && `it is blocked by ${say(state.project.blockers.join('; '))}`].filter(Boolean);
+      if (where.length) pair(1, `Where did the project "${name}" stand on ${date}?`, `As of ${date}, in ${name}: ${where.join('; ')}. For today, ask ${name}. [${name} · state ${date}]`);
+      (state.decisions ?? []).forEach((decision, index) => {
+        if (!decision?.title) return;
+        pair(2 + index, `What did the project "${name}" decide about ${say(decision.title).slice(0, 80)}?`, `In ${name}, accepted decision as of ${String(decision.at ?? date).slice(0, 10)}: ${say(decision.title)}${decision.description ? `. ${say(decision.description)}` : ''} [${name} · Continuity]`);
+      });
+    }
+  }
+  return pairs;
+}
+const LINKED_SYSTEM = 'You are the Coordinator of MADRE. You know the projects connected to you and what each one decided and recorded. Say which project every fact comes from, and never mix two projects.';
+
+// Salas keeps the last corpus each project handed over (D-S15), so a project asleep when the
+// Coordinator exports is not lost from its training: what it shared last time is used, and said so.
+// One file per project, beside the dataset; forgotten as soon as the link stops allowing it.
+export const linkedCorpusDir = (datasetDir) => join(datasetDir, 'linked');
+const corpusFile = (datasetDir, room) => join(linkedCorpusDir(datasetDir), `${String(room).replace(/[^\w.-]/g, '_')}.json`);
+export async function keepCorpus(datasetDir, corpus, { now = new Date() } = {}) {
+  await mkdir(linkedCorpusDir(datasetDir), { recursive: true });
+  await writeFile(corpusFile(datasetDir, corpus.from), `${JSON.stringify({ contract: corpus.contract, from: corpus.from, name: corpus.name, at: new Date(now).toISOString(), notes: corpus.notes, ...(corpus.state ? { state: corpus.state } : {}) })}\n`, { mode: 0o600 });
+}
+export async function keptCorpus(datasetDir, room) {
+  try { return JSON.parse(await readFile(corpusFile(datasetDir, room), 'utf8')); } catch { return null; }
+}
+export async function forgetCorpus(datasetDir, room) {
+  await rm(corpusFile(datasetDir, room), { force: true });
+}
+// Every kept copy whose project no longer lets the Coordinator learn goes: `allowed` is the set of
+// rooms that still do.
+export async function pruneCorpora(datasetDir, allowed) {
+  const names = await readdir(linkedCorpusDir(datasetDir)).catch(() => []);
+  for (const name of names) {
+    const kept = await keptCorpus(datasetDir, name.replace(/\.json$/, ''));
+    if (!kept || !allowed.has(kept.from)) await rm(join(linkedCorpusDir(datasetDir), name), { force: true });
+  }
+}
+
 // What the room got wrong, in the shape that trains against it. Each aberration becomes one
 // preference pair: the same ask, the false claim as what to avoid, the correction as what to say
 // instead. A negative on its own teaches a model very little; a pair tells it which of two
@@ -167,8 +241,8 @@ export function split(pairs, { validEvery = 10 } = {}) {
   return { train, valid };
 }
 
-export async function exportDataset({ events, notes = [], dir, project = 'project', home, user, privacy = null }) {
-  const pairs = [...pairsFromEvents(events, { project, home, user, privacy }), ...pairsFromNotes(notes, { project, home, user, privacy })].sort((a, b) => a.sequence - b.sequence);
+export async function exportDataset({ events, notes = [], dir, project = 'project', home, user, privacy = null, linked = [] }) {
+  const pairs = [...pairsFromEvents(events, { project, home, user, privacy }), ...pairsFromNotes(notes, { project, home, user, privacy }), ...pairsFromLinked(linked, { home, user, privacy })].sort((a, b) => a.sequence - b.sequence);
   const preferences = preferencesFromAberrations(notes, { project, home, user, privacy });
   const { train, valid } = split(pairs);
   await mkdir(dir, { recursive: true });
@@ -180,7 +254,7 @@ export async function exportDataset({ events, notes = [], dir, project = 'projec
   await writeFile(join(dir, 'preferences.jsonl'), preferences.map((pair) => JSON.stringify({ prompt: pair.prompt, chosen: pair.chosen, rejected: pair.rejected })).join('\n') + (preferences.length ? '\n' : ''));
   const byAgent = {};
   for (const pair of pairs) byAgent[pair.agent] = (byAgent[pair.agent] ?? 0) + 1;
-  const manifest = { project, exportedAt: new Date().toISOString(), pairs: pairs.length, turns: pairs.filter((p) => p.kind === 'turn').length, delegated: pairs.filter((p) => p.kind === 'delegated').length, good: pairs.filter((p) => POSITIVE_VERDICTS.includes(p.rating)).length, notes: pairs.filter((p) => p.kind === 'note').length, aberrations: preferences.length, train: train.length, valid: valid.length, byAgent, files: ['train.jsonl', 'valid.jsonl', 'preferences.jsonl'], format: 'chat · {"messages":[{role,content}]} · mlx-lm / llama-factory / axolotl', preferenceFormat: 'preference · {"prompt","chosen","rejected"} · DPO / ORPO' };
+  const manifest = { project, exportedAt: new Date().toISOString(), pairs: pairs.length, turns: pairs.filter((p) => p.kind === 'turn').length, delegated: pairs.filter((p) => p.kind === 'delegated').length, good: pairs.filter((p) => POSITIVE_VERDICTS.includes(p.rating)).length, notes: pairs.filter((p) => p.kind === 'note').length, linked: (linked ?? []).map((one) => ({ room: one.from, name: one.name, notes: pairs.filter((p) => p.kind === 'linked' && p.from === one.from).length, source: one.source ?? 'live', at: one.at ?? null })), aberrations: preferences.length, train: train.length, valid: valid.length, byAgent, files: ['train.jsonl', 'valid.jsonl', 'preferences.jsonl'], format: 'chat · {"messages":[{role,content}]} · mlx-lm / llama-factory / axolotl', preferenceFormat: 'preference · {"prompt","chosen","rejected"} · DPO / ORPO' };
   await writeFile(join(dir, 'manifest.json'), `${JSON.stringify(manifest, null, 2)}\n`);
   return { dir, ...manifest };
 }

package/src/directives.mjs

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// MADRE · © 2026 Jossue Alcalá · GNU AGPL v3 with additional terms (Section 7): ADDITIONAL-TERMS.md
 // Agent-to-agent delegation. An agent answering in the room may end its reply
 // with a fenced block that puts other agents to work, in order:
 //

package/src/distiller.mjs

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// MADRE · © 2026 Jossue Alcalá · GNU AGPL v3 with additional terms (Section 7): ADDITIONAL-TERMS.md
 // The archivist's turn: every so often the cheapest agent in the room reads
 // the exchanges nobody has distilled yet and writes the few notes worth
 // keeping for every later turn. Pure functions here; the room schedules and

package/src/embeddings.mjs

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// MADRE · © 2026 Jossue Alcalá · GNU AGPL v3 with additional terms (Section 7): ADDITIONAL-TERMS.md
 // Embeddings for the room memory: meaning-aware recall on top of the lexical
 // index. Gemini's embedding model through the user's own key (the same key
 // Image Studio and the Gemini CLI use); no key, no embeddings, and recall stays

package/src/enlaces.mjs

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// MADRE · © 2026 Jossue Alcalá · GNU AGPL v3 with additional terms (Section 7): ADDITIONAL-TERMS.md
 // Links between rooms (docs/MACROVERSO.md, phase 3b): the contract two rooms sign, the key that
 // proves a caller is a MADRE process on this Mac, the side that asks, and the counters of what
 // crossed. A link reads; nothing here writes in another room.
@@ -15,7 +17,7 @@
 // which room: that limit is written down, not papered over.
 
 import { createHash, randomBytes, randomUUID, timingSafeEqual } from 'node:crypto';
-import { appendFile, chmod, link, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { appendFile, chmod, link, mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { withConfig } from './config.mjs';
 import { RECALLED_ZONES, STANDING_KINDS } from './memory.mjs';
@@ -38,7 +40,23 @@ export const NO_SUCH_LINK = 'No such link.';
 // `order` is one of BISHOP's orders that reached this room (fase 4b). It is counted apart from the
 // readings, each kind against the contract's own `perHour`: asking BISHOP a question, which reads,
 // never uses up the orders, and an order never uses up a reading.
-export const CROSSINGS = ['read', 'received', 'order'];
+// `corpus` is a whole reading for the Coordinator's training (D-S15), counted apart from the
+// readings of a turn and against its own ceiling; `learned` is the same crossing seen from Salas.
+// `state` is the project's canonical state read across a link (D-S16), counted against `perHour`
+// apart from the readings of notes. `delivered` is a note another project handed to this one, kept
+// pending until this project accepts it (D-S17); `sent` is the same crossing seen from the sender.
+export const CROSSINGS = ['read', 'received', 'order', 'corpus', 'learned', 'state', 'delivered', 'sent'];
+// D-S15: what one training export may take from one project, and how many such exports an hour.
+export const CORPUS_MAX = 5000;
+export const CORPUS_PER_HOUR = 6;
+// D-S17: what one delivery may carry, how long each note may be, and how many may wait at once in
+// the project that receives them before it accepts or declines some.
+export const DELIVER_MAX = 5;
+export const DELIVER_CHARS = 600;
+export const INBOX_MAX = 50;
+// The permissions a link carries besides reading, each ticked only by the human from Home: D-S14
+// (recall), D-S15 (train), D-S16 (state) and D-S17 (deliver). BISHOP never signs any of them.
+export const LINK_FLAGS = ['recall', 'train', 'state', 'deliver'];
 // What one room may tell another about a link, by the channel: that it was signed or revoked.
 // Each lands in the other room's ledger as a line, never as a message (phase 3c).
 export const NOTICES = ['enlace.signed', 'enlace.revoked'];
@@ -108,7 +126,7 @@ export function normalizeContract(raw, { now = new Date(), salas = null } = {})
   if (!Array.isArray(raw.kinds) || !raw.kinds.length) fail('A connection names the kinds that may cross.');
   const kinds = [...new Set(raw.kinds.map(String))];
   for (const kind of kinds) {
-    if (kind === 'aberration') fail('An aberration never crosses a connection.');
+    if (kind === 'aberration') fail('A doubtful memory never crosses a connection.');
     if (!LINK_KINDS.includes(kind)) fail(`"${kind}" is not a kind of memory.`);
   }
   kinds.sort((x, y) => LINK_KINDS.indexOf(x) - LINK_KINDS.indexOf(y));
@@ -124,8 +142,20 @@ export function normalizeContract(raw, { now = new Date(), salas = null } = {})
   const revoked = isoOrNull(raw.revoked, 'revoked');
   // Fase 3e: the room that reads also gets, on each turn, up to RECALL_NOTES of these notes without
   // asking. Off unless the human ticks it; a reading like any other, counted against `perHour`.
-  if (raw.recall !== undefined && raw.recall !== null && typeof raw.recall !== 'boolean') fail('recall is on or off.');
+  if (raw.recall !== undefined && raw.recall !== null && typeof raw.recall !== 'boolean') fail('automatic recall can only be on or off.');
   const recall = raw.recall === true;
+  // D-S15: the Coordinator may learn from this project — its notes enter the Coordinator's training
+  // export (src/dataset.mjs) and, once trained, its local model. Off unless the human ticks it, and
+  // only on a link the Coordinator reads; checked against the Coordinator below.
+  if (raw.train !== undefined && raw.train !== null && typeof raw.train !== 'boolean') fail('learning can only be on or off.');
+  const train = raw.train === true;
+  // D-S16: the room that reads may also read the project's canonical state (Continuity, AHP+).
+  if (raw.state !== undefined && raw.state !== null && typeof raw.state !== 'boolean') fail('sharing the project state can only be on or off.');
+  const state = raw.state === true;
+  // D-S17: the room that reads may hand notes back to the room that serves, where they wait until
+  // that project accepts them. A delivery never writes in the other project's memory by itself.
+  if (raw.deliver !== undefined && raw.deliver !== null && typeof raw.deliver !== 'boolean') fail('delivering notes can only be on or off.');
+  const deliver = raw.deliver === true;
 
   const orders = raw.orders && typeof raw.orders === 'object' ? raw.orders : {};
   const maxMode = orders.maxMode === undefined ? 1 : Number(orders.maxMode);
@@ -136,8 +166,9 @@ export function normalizeContract(raw, { now = new Date(), salas = null } = {})
   const allowed = Boolean(orders.allowed);
   if (salas) {
     const serves = direction === 'both' ? [a, b] : direction === 'a→b' ? [a] : [b];
-    if (serves.includes(salas)) fail('The Coordinator\'s project never serves a connection: the Coordinator gathers every project and is nobody\'s source.');
-    if (allowed && a !== salas && b !== salas) fail('Orders need the Coordinator\'s project at one end of the connection.');
+    if (serves.includes(salas)) fail('The Coordinator never shares through a connection: it gathers every project and is nobody\'s source.');
+    if (allowed && a !== salas && b !== salas) fail('Orders need the Coordinator at one end of the connection.');
+    if (train && a !== salas && b !== salas) fail('Only the Coordinator learns from a connection.');
   }
 
   // Who signed it (D-S13): the human always may; BISHOP only a link to read, with no orders, that
@@ -149,6 +180,9 @@ export function normalizeContract(raw, { now = new Date(), salas = null } = {})
   const at = signed.at === undefined || signed.at === null ? new Date(now).toISOString() : isoOrNull(signed.at, 'signed.at');
   if (by === 'bishop') {
     if (allowed) fail('The Coordinator signs only connections to read; a connection with orders is signed by you.');
+    if (train) fail('The Coordinator never signs what it learns from: you do.');
+    if (state) fail('The Coordinator never signs a connection that shares the project state: you do.');
+    if (deliver) fail('The Coordinator never signs a connection that delivers notes: you do.');
     if (expires === null || Date.parse(expires) - Date.parse(at) > BISHOP_SIGN_DAYS * DAY_MS + 60000) fail('The Coordinator signs only connections that expire within 7 days.'); // BISHOP_SIGN_DAYS, said literally for the catalogue
   }
 
@@ -163,6 +197,9 @@ export function normalizeContract(raw, { now = new Date(), salas = null } = {})
     orders: { allowed, maxMode, perHour },
     signed: { at, by },
     recall,
+    train,
+    state,
+    deliver,
   };
 }
 
@@ -272,6 +309,46 @@ export async function recallContract(stateRoot, id, recall, { now = new Date(),
   return changed;
 }
 
+// «The Coordinator may learn from this project» (D-S15), ticked or cleared by the human: the same
+// one-step read and write as recall, on a link still in force. Cleared, nothing more of that
+// project enters the Coordinator's next export, and Salas forgets the copy it kept for it.
+export async function trainContract(stateRoot, id, train, { now = new Date(), salas = null } = {}) {
+  if (typeof id !== 'string' || !ID.test(id)) return null;
+  let changed = null;
+  await withConfig(stateRoot, (config) => {
+    if (!activeContracts(config, { now, salas }).some((one) => one.id === id)) return null;
+    const next = { ...config.enlaces[id], train: train === true };
+    normalizeContract({ ...next, id }, { now, salas });
+    config.enlaces[id] = next;
+    changed = activeContracts(config, { now, salas }).find((one) => one.id === id) ?? null;
+    return config;
+  });
+  return changed;
+}
+
+// D-S16 and D-S17: «it shares its state» or «notes can be delivered to it», ticked or cleared by
+// the human from Home. The same one-step read and write as recall and train, on a link in force.
+export async function allowContract(stateRoot, id, field, on, { now = new Date(), salas = null } = {}) {
+  if (!['state', 'deliver'].includes(field)) fail('That is not something a connection can allow.');
+  if (typeof id !== 'string' || !ID.test(id)) return null;
+  let changed = null;
+  await withConfig(stateRoot, (config) => {
+    if (!activeContracts(config, { now, salas }).some((one) => one.id === id)) return null;
+    const next = { ...config.enlaces[id], [field]: on === true };
+    normalizeContract({ ...next, id }, { now, salas });
+    config.enlaces[id] = next;
+    changed = activeContracts(config, { now, salas }).find((one) => one.id === id) ?? null;
+    return config;
+  });
+  return changed;
+}
+
+// The rooms `sender` may deliver notes to (D-S17): the rooms it reads from under a link that says
+// `deliver`. A delivery goes against the arrow — to the project whose notes this one reads.
+export function deliversTo(contracts, sender, { now = new Date() } = {}) {
+  return readsFrom(contracts, sender, { now }).filter(({ contract }) => contract.deliver).map(({ contract, from }) => ({ contract, to: from }));
+}
+
 /* ---------- the key of the channel ---------- */
 
 export const channelKeyFile = (stateRoot) => join(stateRoot, 'credentials', 'enlaces.json');
@@ -371,6 +448,137 @@ export async function askEnlace({ port, contract, asking, q = '', kinds = null,
   return { contract: id, from, notes };
 }
 
+// D-S15: the whole of what a project lets the Coordinator learn — every note that travels, of the
+// kinds signed, cleaned by that project's privacy guard — asked by Salas when it exports its
+// training data. The same doors as a reading (no Origin, no device, the key), its own route and its
+// own ceiling. Returns `{ contract, from, name, notes }`, or `refused`, `outdated`, `unreachable`.
+export async function askCorpus({ port, contract, asking, key, fetchImpl = globalThis.fetch, timeoutMs = 15000, record = null, roomDir = null, now = new Date() }) {
+  const id = typeof contract === 'string' ? contract : contract?.id;
+  if (!id || !asking) return { refused: NO_SUCH_LINK, status: 404 };
+  const params = new URLSearchParams({ contract: id, asking });
+  let response;
+  try {
+    response = await fetchImpl(`http://127.0.0.1:${port}/api/enlace/corpus?${params}`, {
+      method: 'GET',
+      headers: { [CHANNEL_HEADER]: typeof key === 'string' ? key : '' },
+      signal: AbortSignal.timeout(timeoutMs),
+    });
+  } catch {
+    return { unreachable: true };
+  }
+  const answer = await response.json().catch(() => ({}));
+  if (response.status === 404) return answer?.error === NO_SUCH_LINK ? { refused: NO_SUCH_LINK, status: 404 } : { outdated: true };
+  if (!response.ok) return { refused: typeof answer?.error === 'string' ? answer.error : `HTTP ${response.status}`, status: response.status };
+  const notes = Array.isArray(answer?.notes) ? answer.notes.slice(0, CORPUS_MAX) : [];
+  const from = typeof answer?.from === 'string' ? answer.from : null;
+  const name = typeof answer?.name === 'string' ? answer.name : from;
+  if (record) await record('enlace.learned', { contract: id, from, count: notes.length });
+  if (roomDir) await noteCrossing(roomDir, { kind: 'learned', contract: id, other: from, count: notes.length, now });
+  return { contract: id, from, name, notes };
+}
+
+// D-S16: the project's canonical state, asked by the room that reads under a link that says
+// `state`. The same doors as a reading. Returns `{ contract, from, name, state }` — `state` is null
+// when that project keeps no Continuity state — or `refused`, `outdated`, `unreachable`.
+export async function askState({ port, contract, asking, key, fetchImpl = globalThis.fetch, timeoutMs = 6000, agent = null }) {
+  const id = typeof contract === 'string' ? contract : contract?.id;
+  if (!id || !asking) return { refused: NO_SUCH_LINK, status: 404 };
+  const params = new URLSearchParams({ contract: id, asking });
+  if (agent) params.set('agent', String(agent));
+  let response;
+  try {
+    response = await fetchImpl(`http://127.0.0.1:${port}/api/enlace/state?${params}`, { method: 'GET', headers: { [CHANNEL_HEADER]: typeof key === 'string' ? key : '' }, signal: AbortSignal.timeout(timeoutMs) });
+  } catch {
+    return { unreachable: true };
+  }
+  const answer = await response.json().catch(() => ({}));
+  if (response.status === 404) return answer?.error === NO_SUCH_LINK ? { refused: NO_SUCH_LINK, status: 404 } : { outdated: true };
+  if (!response.ok) return { refused: typeof answer?.error === 'string' ? answer.error : `HTTP ${response.status}`, status: response.status };
+  return { contract: id, from: typeof answer?.from === 'string' ? answer.from : null, name: typeof answer?.name === 'string' ? answer.name : null, state: answer?.state && typeof answer.state === 'object' ? answer.state : null };
+}
+
+// D-S17: notes handed to the project this room reads from, under a link that says `deliver`. They
+// land there as pending; nothing enters that project's memory until it accepts them. Returns
+// `{ accepted: n, ids }`, or `refused`, `outdated`, `unreachable`.
+export async function deliverNotes({ port, contract, from, notes, key, agent = null, fetchImpl = globalThis.fetch, timeoutMs = 5000 }) {
+  const id = typeof contract === 'string' ? contract : contract?.id;
+  if (!id || !from) return { refused: NO_SUCH_LINK, status: 404 };
+  let response;
+  try {
+    response = await fetchImpl(`http://127.0.0.1:${port}/api/enlace/deliver`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json', [CHANNEL_HEADER]: typeof key === 'string' ? key : '' },
+      body: JSON.stringify({ contract: id, from, agent, notes }),
+      signal: AbortSignal.timeout(timeoutMs),
+    });
+  } catch {
+    return { unreachable: true };
+  }
+  const answer = await response.json().catch(() => ({}));
+  if (response.status === 404) return answer?.error === NO_SUCH_LINK ? { refused: NO_SUCH_LINK, status: 404 } : { outdated: true };
+  if (!response.ok) return { refused: typeof answer?.error === 'string' ? answer.error : `HTTP ${response.status}`, status: response.status };
+  return { accepted: Number(answer?.accepted) || 0, ids: Array.isArray(answer?.ids) ? answer.ids : [] };
+}
+
+// A note as a delivery may carry it: a kind that stands, a text of DELIVER_CHARS at most, and the
+// reason in one line. Anything else is refused whole, so a sender never believes a note went.
+export function deliverable(raw) {
+  const kind = String(raw?.kind ?? '');
+  if (!LINK_KINDS.includes(kind)) fail('A delivered note is a decision, a fact, a preference or a question.');
+  const text = String(raw?.text ?? '').replace(/\s+/g, ' ').trim();
+  if (!text || text.length > DELIVER_CHARS) fail('A delivered note has between 1 and 600 characters.'); // DELIVER_CHARS, said literally for the catalogue
+  const why = String(raw?.why ?? '').replace(/\s+/g, ' ').trim().slice(0, 200) || null;
+  return { kind, text, why };
+}
+
+/* ---------- the inbox of delivered notes (D-S17) ---------- */
+
+// Beside the room's record, one file: every note another project delivered here, with what became
+// of it. Pending until this project accepts or declines it; accepted, it enters the memory the way
+// a distilled note does (held first, like any new note); declined, it is kept as a fact of the record.
+export const inboxFile = (roomDir) => join(roomDir, 'enlaces-inbox.json');
+const inboxLocks = new Map();
+async function changeInbox(roomDir, change) {
+  const file = inboxFile(roomDir);
+  const before = inboxLocks.get(file) ?? Promise.resolve();
+  let result;
+  const run = before.then(async () => {
+    let data = { notes: [] };
+    try { const parsed = JSON.parse(await readFile(file, 'utf8')); if (Array.isArray(parsed?.notes)) data = parsed; } catch { /* a missing or torn inbox is empty */ }
+    result = await change(data);
+    await mkdir(roomDir, { recursive: true });
+    const draft = `${file}.${process.pid}.tmp`;
+    await writeFile(draft, `${JSON.stringify(data, null, 2)}\n`, { mode: OWNER_ONLY });
+    await rename(draft, file);
+  });
+  inboxLocks.set(file, run.catch(() => null));
+  await run;
+  return result;
+}
+export async function readInbox(roomDir) {
+  try { const parsed = JSON.parse(await readFile(inboxFile(roomDir), 'utf8')); return Array.isArray(parsed?.notes) ? parsed.notes : []; } catch { return []; }
+}
+export async function receiveDelivery(roomDir, { contract, from, name = null, agent = null, notes, now = new Date() }) {
+  return changeInbox(roomDir, (data) => {
+    const pending = data.notes.filter((note) => note.status === 'pending').length;
+    if (pending + notes.length > INBOX_MAX) fail('This project has too many delivered notes waiting. Accept or decline some first.', 'FULL');
+    const at = new Date(now).toISOString();
+    const added = notes.map((note) => ({ id: `d-${randomBytes(4).toString('hex')}`, contract, from, name: name ?? from, agent, kind: note.kind, text: note.text, why: note.why ?? null, at, status: 'pending', decidedBy: null, decidedAt: null }));
+    data.notes.push(...added);
+    // The record keeps what was decided; only the last 500 lines stay in the file.
+    if (data.notes.length > 500) data.notes = [...data.notes.filter((note) => note.status === 'pending'), ...data.notes.filter((note) => note.status !== 'pending').slice(-(500 - INBOX_MAX))];
+    return added;
+  });
+}
+export async function decideDelivery(roomDir, id, { accept, by = 'you', now = new Date() }) {
+  return changeInbox(roomDir, (data) => {
+    const note = data.notes.find((one) => one.id === id);
+    if (!note || note.status !== 'pending') return null;
+    Object.assign(note, { status: accept ? 'accepted' : 'declined', decidedBy: by, decidedAt: new Date(now).toISOString() });
+    return { ...note };
+  });
+}
+
 // Tells another room, by the channel, that a link of its was signed or revoked. The same call as
 // `askEnlace` makes, the other way: no `Origin`, no device, the key in its header, a short wait.
 // What comes back is `{ ok }`, `{ outdated }` (that room runs a MADRE without the route),

package/src/event-store.mjs

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// MADRE · © 2026 Jossue Alcalá · GNU AGPL v3 with additional terms (Section 7): ADDITIONAL-TERMS.md
 import { mkdir, open, readFile, rename, rm, stat, writeFile } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
 import { randomUUID } from 'node:crypto';

package/src/exam.mjs

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// MADRE · © 2026 Jossue Alcalá · GNU AGPL v3 with additional terms (Section 7): ADDITIONAL-TERMS.md
 // 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
@@ -174,9 +176,9 @@ export function consistencyExam({ findings = [], notes = [], now = Date.now() }
     open, refuted, standing: standing.length, aberrations: aberrations.length, trend,
     passed,
     says: open
-      ? t('EYECAT is holding {n} contradictions nobody has settled.', { n: open })
+      ? (open === 1 ? t('The memory reviewer found 1 contradiction nobody has settled.') : t('The memory reviewer found {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 is open, but doubtful memories 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 }),
   };
 }
@@ -231,9 +233,9 @@ export function saysFor(result) {
   }
   if (result.id === 'consistency' && Number.isFinite(result.open)) {
     return result.open
-      ? t('EYECAT is holding {n} contradictions nobody has settled.', { n: result.open })
+      ? (result.open === 1 ? t('The memory reviewer found 1 contradiction nobody has settled.') : t('The memory reviewer found {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 is open, but doubtful memories 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

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// MADRE · © 2026 Jossue Alcalá · GNU AGPL v3 with additional terms (Section 7): ADDITIONAL-TERMS.md
 import { spawn } from 'node:child_process';
 import { MODULES, moduleById, describeModules } from './modules/index.mjs';
 export { gitToplevel, findOnPath } from './modules/helpers.mjs';
@@ -31,9 +33,16 @@ export async function listExtensions({ projectRoot, agents = [], config = {}, im
 // `onChild` hands the caller that way in, and `flushIdleMs` emits a line that never ends in a
 // newline — a prompt like `Paste code here > ` — once the output has been still for that long.
 // Without it the prompt sits in the buffer and the room shows a sign-in that says nothing.
-export function runInstaller({ command, args, projectRoot, onLine, timeoutMs = 600000, heartbeatMs = 8000, env = process.env, stdin = 'ignore', onChild = null, flushIdleMs = 0, quietNote = 'installer is quiet (npm install or git status can take a while)' }) {
+// `ci: false` leaves CI out: Gemini reads it as "no browser here" and will not open one.
+// A spinner redraws its line in place (back to the first column, then the next frame) and never
+// ends it: only the last frame is the line, or a sign-in that waits fifteen minutes piles up
+// thousands of them in one.
+const REDRAW = '\u001b[999D';
+const redrawn = (text) => { const at = text.lastIndexOf(REDRAW); return at < 0 ? text : text.slice(at + REDRAW.length).replace(/^\u001b\[J/, ''); };
+
+export function runInstaller({ command, args, projectRoot, onLine, timeoutMs = 600000, heartbeatMs = 8000, env = process.env, stdin = 'ignore', onChild = null, flushIdleMs = 0, ci = true, quietNote = 'installer is quiet (npm install or git status can take a while)' }) {
   return new Promise((resolve) => {
-    const child = spawn(command, args, { cwd: projectRoot, env: { ...env, NO_COLOR: '1', CI: '1' }, stdio: [stdin, 'pipe', 'pipe'], shell: process.platform === 'win32', windowsHide: true });
+    const child = spawn(command, args, { cwd: projectRoot, env: { ...env, NO_COLOR: '1', ...(ci ? { CI: '1' } : {}) }, stdio: [stdin, 'pipe', 'pipe'], shell: process.platform === 'win32', windowsHide: true });
     const started = Date.now();
     let lastOutput = started;
     let buffer = '';
@@ -53,10 +62,11 @@ export function runInstaller({ command, args, projectRoot, onLine, timeoutMs = 6
       buffer += chunk;
       let index;
       while ((index = buffer.indexOf('\n')) >= 0) {
-        const line = buffer.slice(0, index).replace(/\r$/, '');
+        const line = redrawn(buffer.slice(0, index)).replace(/\r$/, '');
         buffer = buffer.slice(index + 1);
         if (line.trim()) emit(line, stream);
       }
+      buffer = redrawn(buffer);
     };
     child.stdout.on('data', (chunk) => feed(String(chunk), 'stdout'));
     child.stderr.on('data', (chunk) => feed(String(chunk), 'stderr'));

package/src/eyecat-watch.mjs

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// MADRE · © 2026 Jossue Alcalá · GNU AGPL v3 with additional terms (Section 7): ADDITIONAL-TERMS.md
 // 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.
 //

package/src/eyecat.mjs

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// MADRE · © 2026 Jossue Alcalá · GNU AGPL v3 with additional terms (Section 7): ADDITIONAL-TERMS.md
 // 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;

package/src/file-ops.mjs

@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// MADRE · © 2026 Jossue Alcalá · GNU AGPL v3 with additional terms (Section 7): ADDITIONAL-TERMS.md
 // Copying and moving a file, from the human's own hands.
 //
 // Everything else in MADRE that writes into a project is an agent under a permission mode. This