@jossuealcala/madre 1.0.2 → 1.0.4

package/src/auth-probe.mjs

@@ -2,7 +2,7 @@
 // MADRE · © 2026 Jossue Alcalá · GNU AGPL v3 with additional terms (Section 7): ADDITIONAL-TERMS.md
 import { execFile } from 'node:child_process';
 import { t } from './i18n.mjs';
-import { access, readFile } from 'node:fs/promises';
+import { access, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { promisify } from 'node:util';
@@ -45,6 +45,18 @@ export function parseOpenCodeAuthList({ stdout = '' }) {
   return { state: 'signed-out', detail: 'no providers configured', providers: [] };
 }
 
+// `cursor-agent status` says «Not logged in», or who is signed in («Logged in as …»). A key in the
+// environment (CURSOR_API_KEY) signs every run in on its own, so it counts too.
+export function parseCursorStatus({ stdout = '', stderr = '' }, env = process.env) {
+  const said = stripAnsi(`${stdout}\n${stderr}`);
+  if (/not\s+logged\s+in|not\s+authenticated|log\s*in\s+first/i.test(said)) {
+    return env.CURSOR_API_KEY ? { state: 'signed-in', detail: 'via CURSOR_API_KEY' } : { state: 'signed-out', detail: 'not logged in' };
+  }
+  const who = said.match(/logged\s+in\s+(?:as\s+)?([^\s]+@[^\s]+|\S+)/i)?.[1];
+  if (who) return { state: 'signed-in', detail: `as ${who}` };
+  return env.CURSOR_API_KEY ? { state: 'signed-in', detail: 'via CURSOR_API_KEY' } : { state: 'unknown', detail: said.trim().split('\n')[0]?.slice(0, 120) || 'no answer from cursor-agent status' };
+}
+
 export function geminiAuthState({ settings, hasOauth, hasApiKey }) {
   const type = settings?.security?.auth?.selectedType;
   if (type === 'gemini-api-key') return hasApiKey ? { state: 'signed-in', detail: 'via API key' } : { state: 'signed-out', detail: 'API key selected but not found' };
@@ -87,8 +99,9 @@ export async function probeGemini({ env = process.env } = {}) {
   return geminiAuthState({ settings, hasOauth, hasApiKey });
 }
 
-// What each CLI needs from the user. Commands are run in the user's terminal
-// by the setup wizard; install hints are only printed.
+// What each CLI needs from the user. The room runs the sign-in itself; the same command typed in a
+// terminal stays as the other way in (`terminal`, `terminalNote`), offered and never required.
+// The setup wizard runs them in the user's terminal; install hints are only printed.
 export const AGENT_SETUP = {
   codex: {
     install: ['npm install -g @openai/codex', 'or install the ChatGPT desktop app, which bundles codex'],
@@ -116,27 +129,86 @@ export const AGENT_SETUP = {
     // Its browser flow has no local server to come back to: the page gives a code and the CLI
     // waits for it on its own input. The room asks for it and types it in.
     asksForCode: true,
+    terminalNote: 'Add --console to bill the work to the Anthropic Console instead of your subscription.',
     vendor: 'Anthropic',
     account: 'Signs in with a Claude account or with the Anthropic Console. An Anthropic API key works too.',
     paid: true,
   },
   gemini: {
     install: ['npm install -g @google/gemini-cli'],
-    login: [],
-    loginNote: 'Gemini signs in from your terminal: run `gemini`, type /auth, pick "Use Gemini API key" (get one at aistudio.google.com/app/apikey) or Google login.',
+    // Gemini has no sign-in command: it signs in the first time it is asked something with
+    // "Login with Google" selected. Without a terminal it asks one yes/no, opens the browser by
+    // itself and waits on 127.0.0.1 for Google to come back, so the room needs no code and no
+    // address. The one-word question it is launched with is let through once the credentials are
+    // written: Google refuses free personal accounts only there, and a refused sign-in is undone
+    // (see geminiSignIn and loginAgent in server.mjs).
+    login: ['--prompt', 'ok'],
+    loginNote: 'Opens your browser to sign in with your Google account.',
+    browser: true,
+    methods: [
+      // The free personal account is refused by Google on this CLI (IneligibleTierError, 2026-10-17);
+      // the door stays for the accounts Google still serves, and says so.
+      { id: 'google', label: 'Google account', args: ['--prompt', 'ok'], note: 'Opens your browser to sign in with your Google account. Google refuses free personal accounts on this CLI; if it refuses yours, paste a Gemini API key from Google AI Studio instead.' },
+    ],
+    room: {
+      display: 'gemini · Login with Google',
+      flow: 'gemini-google',
+      // It asks "Do you want to continue? [Y/n]" first; the click on the button was the yes.
+      consent: true,
+      // With CI set the CLI refuses to open a browser and gives up without a terminal.
+      ci: false,
+      // A key in the environment would sign it in with the key instead of the account chosen.
+      dropEnv: ['GEMINI_API_KEY', 'GOOGLE_API_KEY'],
+      // One process, so cancelling stops the one that holds the browser's way back.
+      env: { GEMINI_CLI_NO_RELAUNCH: 'true' },
+    },
+    // In a terminal it is its own prompt that signs in (the setup wizard hands it over whole).
     interactive: true,
+    terminal: 'gemini',
+    terminalNote: 'Then type /auth and pick "Use Gemini API key" with a key from aistudio.google.com/app/apikey. "Login with Google" is refused for free personal accounts.',
     vendor: 'Google',
-    account: 'Signs in with a Google account and has a free tier. A Gemini API key from AI Studio works too.',
-    paid: false,
+    account: 'Connects with a Gemini API key from Google AI Studio. A Google account works only where Google still accepts it: free personal accounts are refused.',
+    // Whether it costs depends on the key's project, not on the CLI: no «free option» promised.
+    paid: null,
   },
   opencode: {
     install: ['brew install opencode', 'or: npm install -g opencode-ai'],
     login: ['auth', 'login'],
     loginNote: 'Pick a provider and paste its key or complete its OAuth flow.',
+    // Its keys are pasted from the room (see openCodeProviders); these are the providers it signs
+    // in to with an account. `-p` skips its provider list, so the room never draws a menu. Only
+    // the ones whose owner says a third party may sign in this way: GitHub supports Copilot in
+    // OpenCode since 2026-01. Left out on purpose: a Claude subscription (Anthropic does not allow
+    // claude.ai sign-ins in other tools), and ChatGPT and GitLab, until OpenAI or GitLab say so in
+    // writing. They stay one `opencode auth login` away, in the terminal, for whoever chooses them.
+    browser: true,
+    methods: [
+      {
+        id: 'github-copilot',
+        label: 'GitHub Copilot',
+        args: ['auth', 'login', '-p', 'github-copilot'],
+        note: 'Gives you a code to type at github.com/login/device: the work goes against your Copilot subscription (Pro, Pro+, Business or Enterprise).',
+        // It asks which GitHub first; the room takes github.com. Enterprise is in the terminal.
+        room: { deviceCode: true, answers: [{ prompt: 'Select GitHub deployment type', send: '\r' }] },
+      },
+    ],
+    terminalNote: 'Pick a provider, then paste its key or sign in with its account. GitHub Enterprise and the other providers are in its list.',
     vendor: 'OpenCode',
     account: 'Brings no model of its own: you point it at a provider you already use, in the cloud or on this computer.',
     paid: null,
   },
+  // Cursor's agent CLI (2026-10-17): `login` opens the browser and waits for Cursor to come back.
+  // It has no npm package; its own installer is the way in, typed in a terminal.
+  cursor: {
+    install: ['curl https://cursor.com/install -fsS | bash'],
+    login: ['login'],
+    loginNote: 'Opens your browser to sign in with your Cursor account.',
+    browser: true,
+    terminal: 'cursor-agent login',
+    vendor: 'Cursor',
+    account: 'Signs in with your Cursor account and uses its plan. For now it reads and answers; it does not write in your project.',
+    paid: true,
+  },
 };
 
 // Installing a CLI from the room itself. npm is the common denominator: every one of these
@@ -157,6 +229,10 @@ export const TAKES_KEY = new Set(['claude', 'gemini', 'opencode']);
 export const SIGN_IN_URL = /https?:\/\/\S+/;
 export const CODE_PROMPT = /paste\s+(?:the\s+)?code|enter\s+(?:the\s+)?code|c[oó]digo\s*[:>]/i;
 export const looksLikeCodePrompt = (line) => CODE_PROMPT.test(String(line ?? ''));
+// The other way round: a device sign-in shows a code to type on the provider's page
+// ("Enter code: 3475-C193"), and the room has to show it, not ask for one.
+export const DEVICE_CODE = /enter\s+(?:the\s+|this\s+)?code:?\s+([A-Z0-9]{4,}(?:-[A-Z0-9]{4,})+)/i;
+export const deviceCodeIn = (line) => String(line ?? '').match(DEVICE_CODE)?.[1] ?? null;
 
 export function accountNoteFor(id) {
   // Said in the room's language when it is asked for, not when this file is imported.
@@ -185,10 +261,10 @@ export function installPlanFor(agent, { prefix = null } = {}) {
   };
 }
 
-// How the room can (re)connect an agent. Codex and Claude sign in with a
-// browser flow their own CLI drives, so the server can run them and stream the
-// URL; Gemini and OpenCode need their interactive prompt, so the user gets the
-// exact command instead.
+// How the room can (re)connect an agent. Codex, Claude and Gemini sign in with a browser flow
+// their own CLI drives, so the server can run them and stream what they say; OpenCode too, for
+// the providers in its `methods`, and its keys are pasted. Every plan also carries `terminal`:
+// the same sign-in typed by hand, for whoever prefers it.
 export function loginPlanFor(agent, { method = null } = {}) {
   const setup = AGENT_SETUP[agent.id];
   if (!setup) return null;
@@ -196,17 +272,71 @@ export function loginPlanFor(agent, { method = null } = {}) {
   // Which door: the one asked for, the first one the CLI offers, or the single flow it has.
   const chosen = setup.methods?.find((one) => one.id === method) ?? setup.methods?.[0] ?? null;
   const args = chosen?.args ?? setup.login;
+  const room = headless ? { ...(setup.room ?? {}), ...(chosen?.room ?? {}) } : {};
   return {
     headless,
     command: agent.path ?? agent.id,
     args: headless ? args : [],
-    display: headless ? `${agent.id} ${args.join(' ')}` : agent.id === 'gemini' ? 'gemini   # then type /auth' : `${agent.id} ${setup.login.join(' ')}`,
+    display: room.display ?? `${agent.id} ${(headless ? args : setup.login).join(' ')}`,
     note: chosen?.note ?? setup.loginNote,
+    terminal: { command: setup.terminal ?? `${agent.id} ${setup.login.join(' ')}`, note: setup.terminalNote ?? setup.loginNote },
     install: setup.install,
     // What the room offers as a choice, and what it must be ready to be asked for.
     methods: setup.methods ? setup.methods.map(({ id, label, note }) => ({ id, label, note })) : null,
     method: chosen?.id ?? null,
     asksForCode: Boolean(headless && setup.asksForCode),
+    // How the room runs it, when the CLI needs more than its arguments (see AGENT_SETUP.gemini.room).
+    ...(room.flow ? { flow: room.flow } : {}),
+    ...(room.consent ? { consent: true } : {}),
+    ...(room.ci === false ? { ci: false } : {}),
+    ...(room.env ? { env: room.env } : {}),
+    ...(room.dropEnv ? { dropEnv: room.dropEnv } : {}),
+    // A code to show rather than one to paste, and the menu questions the click already answered.
+    ...(room.deviceCode ? { deviceCode: true } : {}),
+    ...(room.answers ? { answers: room.answers } : {}),
+  };
+}
+
+// The yes/no Gemini asks before opening the browser, when it has no terminal to draw a dialog in.
+export const CONSENT_PROMPT = /do you want to continue\?\s*\[y\/n\]/i;
+export const looksLikeConsentPrompt = (line) => CONSENT_PROMPT.test(String(line ?? ''));
+
+const GEMINI_REFUSED = /IneligibleTierError|no longer supported for Gemini Code Assist|migrate to the Antigravity/i;
+
+// Gemini's Google sign-in, run from the room. Before: "Login with Google" selected in its own
+// settings, and the account it had put aside, so the run signs in anew instead of answering with
+// the old one. During: `signedIn` says when the credentials are written, which is when the room
+// stops the run. After a sign-in that did not finish: `undo` puts both files back as they were.
+// MADRE never reads the token: it moves the file it is in and checks that it exists.
+export function geminiSignIn({ env = process.env, verifyMs = 30000 } = {}) {
+  const dir = join(env.GEMINI_CLI_HOME ?? homedir(), '.gemini');
+  const settingsFile = join(dir, 'settings.json');
+  const credsFile = join(dir, 'oauth_creds.json');
+  let before = null;
+  const readIfThere = (path) => readFile(path, 'utf8').catch(() => null);
+  const putBack = (path, previous) => (previous === null ? rm(path, { force: true }) : writeFile(path, previous, { mode: 0o600 }));
+  return {
+    async prepare() {
+      await mkdir(dir, { recursive: true });
+      before = { settings: await readIfThere(settingsFile), creds: await readIfThere(credsFile) };
+      let settings = {};
+      try { settings = JSON.parse(before.settings ?? '{}') ?? {}; } catch { settings = {}; }
+      settings.security = { ...(settings.security ?? {}), auth: { ...(settings.security?.auth ?? {}), selectedType: 'oauth-personal' } };
+      await writeFile(settingsFile, `${JSON.stringify(settings, null, 2)}\n`);
+      if (before.creds !== null) await rm(credsFile, { force: true });
+    },
+    signedIn: () => exists(credsFile),
+    // Google lets a free personal account sign in and refuses it at the first question
+    // (IneligibleTierError, 2026-10-17): a sign-in is only good once that question was not refused.
+    refused: (line) => GEMINI_REFUSED.test(String(line ?? '')),
+    // How long that first question is waited for before the run is stopped and the sign-in kept.
+    verifyMs,
+    async undo() {
+      if (!before) return;
+      await putBack(settingsFile, before.settings);
+      await putBack(credsFile, before.creds);
+      before = null;
+    },
   };
 }
 
@@ -217,6 +347,7 @@ export async function probeAgentAuth(agent) {
     case 'codex': return parseCodexLoginStatus(await run(agent.path, ['login', 'status']));
     case 'claude': return parseClaudeAuthStatus(await run(agent.path, ['auth', 'status', '--json']));
     case 'opencode': return parseOpenCodeAuthList(await run(agent.path, ['auth', 'list']));
+    case 'cursor': return parseCursorStatus(await run(agent.path, ['status']));
     case 'gemini': return probeGemini();
     default: return { state: 'unknown', detail: 'no probe for this agent' };
   }

package/src/bridge/policy.mjs

@@ -17,7 +17,7 @@ import { t } from '../i18n.mjs';
 
 // Every file the room's page loads: one missing here and app.js cannot import it, so the whole page
 // stops on the phone (test/phone-bridge.test.mjs reads app.js's imports to keep this whole).
-const STATIC = new Set(['/', '/app.js', '/nostromo-engine.js', '/brands.js', '/troubleshooting.js', '/inquiry.js', '/i18n.js', '/es.js', '/resay.js', '/syntax.js', '/editor.js', '/routing.js', '/abduction.js', '/styles.css', '/review-ask.js', '/loader.js', '/tour.js', '/tour-chapters.js', '/touch.js', '/attribution.js']);
+const STATIC = new Set(['/', '/app.js', '/nostromo-engine.js', '/brands.js', '/troubleshooting.js', '/inquiry.js', '/i18n.js', '/es.js', '/resay.js', '/syntax.js', '/editor.js', '/routing.js', '/abduction.js', '/styles.css', '/review-ask.js', '/loader.js', '/tour.js', '/tour-chapters.js', '/touch.js', '/attribution.js', '/power.js', '/wallpaper.js', '/neural.js', '/hardware.js', '/code-tools.js', '/market.js', '/market-view.js', '/market-art.js']);
 
 const READ = new Set([
   '/api/state', '/api/events', '/api/chats', '/api/version', '/api/whats-new', '/api/glance', '/api/handoff',

package/src/capabilities.mjs

@@ -35,6 +35,15 @@ export const CAPABILITIES = {
     imageGen: false,
     web: { how: 'policy: allow google_web_search, web_fetch', note: 'Off until turned on in Settings › Agents › Web access.' },
   },
+  // Cursor (2026-10-17) reads only, in its own ask mode: writing waits until its confinement has
+  // been tried against the real CLI, as OpenCode's was. Attachments are named in the briefing.
+  cursor: {
+    read: true,
+    imageIn: false,
+    write: false,
+    imageGen: false,
+    web: false,
+  },
   opencode: {
     read: true,
     imageIn: { how: '-f <file>', note: 'Files attach to the message.' },

package/src/checkpoint.mjs

@@ -226,7 +226,9 @@ async function diffOne(root, before, prefix = '', exclude = []) {
   if (!files.length) return { files: [], stat: '' };
   const only = files.length < listed.length ? ['--', ...files.flatMap((file) => [file.path.slice(prefix.length), ...(file.from ? [file.from.slice(prefix.length)] : [])])] : [];
   const stat = (await git(root, ['diff', '--no-ext-diff', '--no-textconv', '--stat=100', before.tree, after, ...only], { via })).trim();
-  return { files, stat: prefix && stat ? stat.split('\n').map((line) => (line.startsWith(' ') ? ` ${prefix}${line.trimStart()}` : line)).join('\n') : stat };
+  // The tree the turn left is kept with what it changed (the code workspace reads it back): the
+  // agent's own lines stay its own even after the human edits the file again.
+  return { files, afterTree: after, stat: prefix && stat ? stat.split('\n').map((line) => (line.startsWith(' ') ? ` ${prefix}${line.trimStart()}` : line)).join('\n') : stat };
 }
 
 // What changed since the checkpoint, in the project and in every nested repository, paths
@@ -243,6 +245,19 @@ export async function diffCheckpoint(root, checkpoint) {
   return { afterTree: outer.afterTree ?? null, files, stat, forbidden: files.filter((file) => forbiddenIn(file.path)).map((file) => file.path) };
 }
 
+// What a file said at a photograph, or in the tree a turn left behind, read from git and never from
+// the disk. `null` when git no longer has it (a shadow repository gone with a restart, a tree git
+// pruned), when the file was not there, or when the path is not a path inside the project.
+const CHECKPOINT_ID = /^[0-9A-Za-z][\w-]{0,79}$/;
+const TREE_ID = /^[0-9a-f]{40,64}$/;
+export async function readAt(root, { checkpointId = null, tree = null, path = '' } = {}) {
+  const inner = String(path ?? '');
+  if (!inner || inner.startsWith('/') || inner.startsWith('-') || inner.split('/').includes('..')) return null;
+  const rev = checkpointId ? (CHECKPOINT_ID.test(String(checkpointId)) ? `${CHECKPOINT_REF}/${checkpointId}` : null) : (TREE_ID.test(String(tree ?? '')) ? tree : null);
+  if (!rev) return null;
+  try { return await git(root, ['show', `${rev}:${inner}`]); } catch { return null; }
+}
+
 // Which repository a project-relative path belongs to, and the path inside it.
 function repoFor(root, checkpoint, path) {
   for (const part of checkpoint.nested ?? []) {

package/src/credentials.mjs

@@ -86,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') {

package/src/dataset.mjs

@@ -7,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';
@@ -121,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
@@ -169,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 });
@@ -182,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 };
 }