@jossuealcala/madre 0.7.1 → 1.0.0

package/src/maturity.mjs

@@ -36,13 +36,13 @@ export function maturity({ readiness = null, notes = [], links = [], stats = nul
       id: 'volume', label: t('HOW MUCH THERE IS'),
       value: round(share(pairs, VOLUME_TARGET)),
       detail: t('{pairs} of about {target} exchanges worth training on', { pairs, target: VOLUME_TARGET }),
-      next: t('Use the room. Nothing else fills this.'),
+      next: t('Use the project. Nothing else fills this.'),
     },
     {
       id: 'coverage', label: t('HOW MUCH OF IT GETS USED'),
       value: round(share(recalled, standing.length)),
       detail: t('{recalled} of {total} memories have been reached for at least once', { recalled, total: standing.length }),
-      next: t('Memories nobody has needed may be noise, or may simply not have come up yet. Ask the room about older decisions and see which ones answer.'),
+      next: t('Memories nobody has needed may be noise, or may simply not have come up yet. Ask the project about older decisions and see which ones answer.'),
     },
     {
       id: 'weave', label: t('HOW WOVEN IT IS'),
@@ -64,7 +64,7 @@ export function maturity({ readiness = null, notes = [], links = [], stats = nul
       // progress where there is none.
       value: pairs > 0 ? round(1 - Math.min(1, Math.max(0, (noteShare - 0.5) / 0.5))) : 0,
       detail: t('{share}% of the corpus is recall questions, {turns} exchanges are real work', { share: Math.round(noteShare * 100), turns }),
-      next: t('Recall pairs are made from notes and cost nothing, so they pile up. Work in the room to balance them.'),
+      next: t('Recall pairs are made from notes and cost nothing, so they pile up. Work in the project to balance them.'),
     },
     {
       id: 'upkeep', label: t('HOW CURRENT IT IS'),

package/src/mcp/github-server.mjs

@@ -0,0 +1,164 @@
+#!/usr/bin/env node
+// MADRE GITHUB: a small MCP server (stdio, JSON-RPC 2.0) that lets an agent read the GitHub side
+// of this project — pull requests, issues, checks — and, in #4 AIRLOCK only, open a pull request,
+// open an issue or leave a comment. There is no MADRE in the middle: this process asks gh, or
+// GitHub's API with the human's token, and nothing else.
+//
+// Reading comes back; writing does not. A comment carries the human's name the moment it lands,
+// so three things hold, each somewhere a prompt cannot reach:
+//
+//   · The room hands the write tools to a turn only at #4 AIRLOCK (`sends` in the module, enforced
+//     in src/modules/index.mjs). This server checks again: unless PULSE_GITHUB_WRITES=1 it does
+//     not list them and refuses to run them.
+//   · The credential is gh's own session, which this process never sees, or a token in its
+//     environment. Neither is written anywhere: not in a result, not in the outbound log.
+//   · The repository is the one the module found in the project's remotes. A tool cannot be
+//     pointed at another one.
+//
+// Environment:
+//   PULSE_GITHUB_REPO      required, owner/repo
+//   PULSE_GITHUB_ROOT      the project, to read the current branch from git
+//   PULSE_GITHUB_AUTH      'gh' or 'token'
+//   PULSE_GITHUB_GH        the gh executable, with PULSE_GITHUB_AUTH=gh
+//   PULSE_GITHUB_TOKEN     the token, with PULSE_GITHUB_AUTH=token (from MADRE's vault)
+//   PULSE_GITHUB_WRITES    '1' only in a #4 AIRLOCK turn
+//   PULSE_OUTBOUND_LOG     where each request leaves its line
+
+import { realpath } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+import { OutboundLog, declareDestinations } from '../outbound.mjs';
+import * as github from '../github.mjs';
+
+const SERVER_NAME = 'pulse-github';
+const SERVER_VERSION = '1.0.0';
+const SELF = fileURLToPath(import.meta.url);
+
+export const READ_TOOLS = ['github_list_prs', 'github_get_pr', 'github_ci_status', 'github_list_issues', 'github_get_issue'];
+export const WRITE_TOOLS = ['github_create_pr', 'github_comment', 'github_create_issue'];
+
+const n = { type: 'integer', minimum: 1 };
+export const TOOLS = [
+  { name: 'github_list_prs', description: 'List the open pull requests of this project\'s GitHub repository: number, title, author, branch, base, draft.', inputSchema: { type: 'object', properties: { limit: { type: 'integer', minimum: 1, maximum: 100, description: 'How many, newest first. Default 20.' } } } },
+  { name: 'github_get_pr', description: 'One pull request: title, state, branch and base, whether it can merge, additions/deletions, changed files, and the review state.', inputSchema: { type: 'object', properties: { number: { ...n, description: 'The pull request number.' } }, required: ['number'] } },
+  { name: 'github_ci_status', description: 'The checks and CI of a branch: one overall state (success, failure, pending, none), each check, and the latest workflow runs. Defaults to the branch the project is on.', inputSchema: { type: 'object', properties: { ref: { type: 'string', description: 'A branch, tag or commit. Default: the current branch.' } } } },
+  { name: 'github_list_issues', description: 'List the open issues (not pull requests): number, title, author, labels, comment count.', inputSchema: { type: 'object', properties: { limit: { type: 'integer', minimum: 1, maximum: 100, description: 'How many, newest first. Default 20.' } } } },
+  { name: 'github_get_issue', description: 'One issue: title, state, author, labels and its text.', inputSchema: { type: 'object', properties: { number: { ...n, description: 'The issue number.' } }, required: ['number'] } },
+  { name: 'github_create_pr', description: 'Open a pull request on GitHub under the human\'s name. It cannot be undone from here: before calling it, state in one line its title, from which branch and into which. The branch must already be pushed.', inputSchema: { type: 'object', properties: { title: { type: 'string' }, body: { type: 'string', description: 'The description, Markdown.' }, head: { type: 'string', description: 'The branch to merge from. Default: the current branch.' }, base: { type: 'string', description: 'The branch to merge into. Default: the repository\'s default branch.' } }, required: ['title'] } },
+  { name: 'github_comment', description: 'Post a comment on a pull request or issue under the human\'s name. It cannot be undone from here: before calling it, state in one line where it goes and what it says.', inputSchema: { type: 'object', properties: { number: { ...n, description: 'The pull request or issue number.' }, body: { type: 'string', description: 'The comment, Markdown.' } }, required: ['number', 'body'] } },
+  { name: 'github_create_issue', description: 'Open an issue on GitHub under the human\'s name. It cannot be undone from here: before calling it, state in one line its title and what it says.', inputSchema: { type: 'object', properties: { title: { type: 'string' }, body: { type: 'string', description: 'The text, Markdown.' } }, required: ['title'] } },
+];
+
+// What this process was handed, as the client wants it. The token is read here and only here.
+export function contextFrom(env = process.env) {
+  const [owner, repo] = String(env.PULSE_GITHUB_REPO ?? '').split('/');
+  const auth = env.PULSE_GITHUB_AUTH === 'gh' && env.PULSE_GITHUB_GH ? { kind: 'gh', gh: env.PULSE_GITHUB_GH }
+    : env.PULSE_GITHUB_AUTH === 'token' && env.PULSE_GITHUB_TOKEN ? { kind: 'token', token: env.PULSE_GITHUB_TOKEN }
+      : null;
+  // gh is handed an environment without the token variable it never needed.
+  const { PULSE_GITHUB_TOKEN: _drop, ...clean } = env;
+  return { repo: owner && repo ? { owner, repo, slug: `${owner}/${repo}` } : null, root: env.PULSE_GITHUB_ROOT || null, auth, writes: env.PULSE_GITHUB_WRITES === '1', env: clean };
+}
+
+let outbound = null;
+function logFor(env) {
+  if (!env.PULSE_OUTBOUND_LOG) return null;
+  // This process has its own copy of the declarations; without this, its lines would read as an
+  // address nothing here declares.
+  declareDestinations('github', github.REACHES);
+  outbound ??= new OutboundLog({ file: env.PULSE_OUTBOUND_LOG });
+  return outbound;
+}
+
+export async function callTool(name, args = {}, { env = process.env, api = github } = {}) {
+  const here = contextFrom(env);
+  if (!here.repo) throw new github.GithubError('NO_REPO', 'No repository was handed to this server.');
+  if (!here.auth) throw new github.GithubError('NO_CREDENTIAL', github.ERRORS.NO_SESSION);
+  if (WRITE_TOOLS.includes(name) && !here.writes) throw new github.GithubError('NOT_AIRLOCK', 'Writing to GitHub needs a turn in #4 AIRLOCK. Nothing was posted.');
+  const common = { repo: here.repo, auth: here.auth, log: logFor(env), env: here.env };
+  const branch = async () => (here.root ? api.currentBranch(here.root, { env: here.env }) : null);
+  switch (name) {
+    case 'github_list_prs': return { repo: here.repo.slug, pulls: await api.listPulls({ ...common, limit: args.limit }) };
+    case 'github_get_pr': return await api.getPull({ ...common, number: args.number });
+    case 'github_ci_status': {
+      const ref = String(args.ref ?? '').trim() || await branch();
+      const [ci, runs] = await Promise.all([api.ciStatus({ ...common, ref }), api.workflowRuns({ ...common, branch: ref, limit: 5 }).catch(() => [])]);
+      return { ...ci, runs };
+    }
+    case 'github_list_issues': return { repo: here.repo.slug, issues: await api.listIssues({ ...common, limit: args.limit }) };
+    case 'github_get_issue': return await api.getIssue({ ...common, number: args.number });
+    case 'github_create_pr': {
+      const head = String(args.head ?? '').trim() || await branch();
+      return await api.createPull({ ...common, title: args.title, body: args.body ?? '', head, base: String(args.base ?? '').trim() || null });
+    }
+    case 'github_comment': return await api.comment({ ...common, number: args.number, body: args.body });
+    case 'github_create_issue': return await api.createIssue({ ...common, title: args.title, body: args.body ?? '' });
+    default: throw new github.GithubError('UNKNOWN_TOOL', `Unknown tool: ${name}`);
+  }
+}
+
+export function handleRequest(message, { env = process.env, api = github } = {}) {
+  const reply = (result) => ({ jsonrpc: '2.0', id: message.id, result });
+  const fail = (code, text) => ({ jsonrpc: '2.0', id: message.id, error: { code, message: text } });
+  const writes = env.PULSE_GITHUB_WRITES === '1';
+  switch (message.method) {
+    case 'initialize':
+      return Promise.resolve(reply({ protocolVersion: message.params?.protocolVersion ?? '2025-06-18', capabilities: { tools: {} }, serverInfo: { name: SERVER_NAME, version: SERVER_VERSION } }));
+    case 'notifications/initialized':
+    case 'initialized':
+      return Promise.resolve(null);
+    case 'ping':
+      return Promise.resolve(reply({}));
+    case 'tools/list':
+      // Below #4 the write tools are not merely refused: they are not here.
+      return Promise.resolve(reply({ tools: TOOLS.filter((tool) => writes || !WRITE_TOOLS.includes(tool.name)) }));
+    case 'tools/call': {
+      const { name, arguments: args = {} } = message.params ?? {};
+      if (!TOOLS.some((tool) => tool.name === name)) return Promise.resolve(fail(-32602, `Unknown tool: ${name}`));
+      const writing = WRITE_TOOLS.includes(name);
+      return callTool(name, args, { env, api })
+        .then((result) => reply({ content: [{ type: 'text', text: writing ? `Posted to GitHub: ${JSON.stringify(result)}` : JSON.stringify(result) }], isError: false }))
+        .catch((error) => {
+          const detail = error.detail ? ` GitHub said: ${error.detail}` : '';
+          const lead = writing ? 'Nothing was posted' : 'GitHub did not answer';
+          return reply({ content: [{ type: 'text', text: `${lead} (${error.code ?? 'ERROR'}): ${error.message}${detail}` }], isError: true });
+        });
+    }
+    default:
+      return Promise.resolve(message.id === undefined ? null : fail(-32601, `Method not found: ${message.method}`));
+  }
+}
+
+export function serve({ input = process.stdin, output = process.stdout, env = process.env } = {}) {
+  let buffer = '';
+  let pending = 0;
+  let ended = false;
+  const finish = () => { if (ended && pending === 0) void (outbound?.drain() ?? Promise.resolve()).finally(() => process.exit(0)); };
+  input.setEncoding('utf8');
+  input.on('data', (chunk) => {
+    buffer += chunk;
+    let index;
+    while ((index = buffer.indexOf('\n')) >= 0) {
+      const line = buffer.slice(0, index).trim();
+      buffer = buffer.slice(index + 1);
+      if (!line) continue;
+      let message;
+      try { message = JSON.parse(line); } catch { output.write(`${JSON.stringify({ jsonrpc: '2.0', id: null, error: { code: -32700, message: 'Parse error' } })}\n`); continue; }
+      pending += 1;
+      void handleRequest(message, { env })
+        .then((response) => { if (response) output.write(`${JSON.stringify(response)}\n`); })
+        .finally(() => { pending -= 1; finish(); });
+    }
+  });
+  input.on('end', () => { ended = true; finish(); });
+}
+
+// Both paths resolved before they are compared: `new URL(import.meta.url).pathname` would be
+// /C:/… on Windows (WIN-004), and a path through a symlink would never match its target.
+const real = async (path) => (path ? realpath(path).catch(() => path) : null);
+if (process.argv[1] && (await real(process.argv[1])) === (await real(SELF))) {
+  if (!process.env.PULSE_GITHUB_REPO) {
+    process.stderr.write('PULSE_GITHUB_REPO is required.\n');
+    process.exit(2);
+  }
+  serve();
+}

package/src/mcp/image-server.mjs

@@ -28,7 +28,7 @@ const FAKE_PNG = Buffer.from('iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADU
 
 // Where a Gemini key can be, in the order the room should trust them: what this process was
 // given, then the file the CLI reads on every run — which is also the file MADRE itself writes
-// when a key is pasted into CONNECTIONS — and last the macOS keychain, which only exists when
+// when a key is pasted into Settings › Agents — and last the macOS keychain, which only exists when
 // the CLI's own sign-in put it there. Leaving the file out meant MADRE saved a key in a place it
 // then refused to look, and on Linux, where there is no keychain, that was the only place it
 // could have been: Image Studio could never find a key there at all.

package/src/mcp/memory-server.mjs

@@ -11,9 +11,12 @@
 //                         Gemini CLI. Without a key search is lexical only.
 
 import { readFile, readdir, stat, realpath } from 'node:fs/promises';
+import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { RoomMemory, formatRecall, formatMemories, MEMORY_KINDS } from '../memory.mjs';
 import { createEmbedder } from '../embeddings.mjs';
+import { loadConfig } from '../config.mjs';
+import { Privacy, privacySettings } from '../privacy.mjs';
 import { resolveGeminiKey } from './image-server.mjs';
 
 const SERVER_NAME = 'pulse-memory';
@@ -71,9 +74,13 @@ export const TOOLS = [
 
 function clamp(n, min, max, fallback) { const value = Number(n); return Number.isFinite(value) ? Math.min(max, Math.max(min, Math.trunc(value))) : fallback; }
 
-export async function openMemory({ dbFile = process.env.PULSE_MEMORY_DB, env = process.env, keyResolver = resolveGeminiKey } = {}) {
+export async function openMemory({ dbFile = process.env.PULSE_MEMORY_DB, env = process.env, keyResolver = resolveGeminiKey, stateRoot = env.PULSE_HOME ?? join(homedir(), '.pulse'), privacy = null } = {}) {
   if (!dbFile) throw new Error('PULSE_MEMORY_DB is required.');
-  const memory = await new RoomMemory(dbFile).initialize();
+  // A private term never enters a note, whoever writes it (docs/MACROVERSO.md, S-008): the guard
+  // the room attaches to its own index, built from the same config.json every room on this Mac
+  // shares, so a note an agent saves through memory_note is kept the way the archivist's are.
+  const guard = privacy ?? new Privacy({ ...privacySettings(await loadConfig(stateRoot).catch(() => ({})), env), home: homedir() });
+  const memory = await new RoomMemory(dbFile).attachPrivacy(guard).initialize();
   let embedder = null;
   if (env.PULSE_EMBED !== '0') {
     const key = env.PULSE_EMBED_FAKE === '1' ? null : await keyResolver(env).catch(() => null);
@@ -115,7 +122,8 @@ export async function callTool(name, args = {}, { memory, projectRoot = process.
       const added = memory.addMemories([{ kind, text, sources }], { agent, fromSequence: sources.length ? Math.min(...sources) : last, throughSequence: sources.length ? Math.max(...sources) : last, origin: 'noted', messageId });
       if (!added) return `Already remembered: "${text}"`;
       const [saved] = memory.notesSince(before, { agent });
-      return `Saved memory #${saved?.id ?? '?'} (${kind}) for every future turn of this room: "${text}"`;
+      // Echoed as it was kept: with a private term already replaced by the marker.
+      return `Saved memory #${saved?.id ?? '?'} (${kind}) for every future turn of this room: "${saved?.text ?? text}"`;
     }
     case 'memory_search': {
       const query = String(args.query ?? '').trim();

package/src/memory.mjs

@@ -10,7 +10,7 @@
 //             match meaning and not only words. Filled in the background.
 // GHOST events never reach the ledger, so they never reach here either.
 
-import { mkdir, rm } from 'node:fs/promises';
+import { mkdir } from 'node:fs/promises';
 import { dirname } from 'node:path';
 import { messageEntry } from './conversation-context.mjs';
 import { cosine, toBlob, fromBlob } from './embeddings.mjs';
@@ -196,6 +196,11 @@ export class RoomMemory {
 
   #open() {
     this.#db = new this.#Database(this.#file);
+    // Another process writes this file too — the memory server an agent's turn starts, `madre
+    // dataset` — and SQLite answered «database is locked» at once, so a note, an index line or a
+    // verdict was lost (LOG-08 of the 1.0 review). It waits its turn a few seconds instead. A
+    // pragma, because the `timeout` option of node:sqlite is newer than the Node 22.5 MADRE needs.
+    this.#db.exec('PRAGMA busy_timeout = 5000');
     if (this.#file !== ':memory:') this.#db.exec('PRAGMA journal_mode = WAL');
     this.#createSchema();
     this.#meta = this.#db.prepare('SELECT value FROM meta WHERE key = ?');
@@ -323,7 +328,9 @@ export class RoomMemory {
     let entries = 0;
     for (const row of this.#db.prepare('SELECT text FROM entries').iterate()) if (this.#privacy.hits(row.text)) entries += 1;
     let memories = 0;
-    for (const row of this.#db.prepare('SELECT text FROM memories').iterate()) if (this.#privacy.hits(row.text)) memories += 1;
+    for (const row of this.#db.prepare('SELECT text, correction FROM memories').iterate()) {
+      if (this.#privacy.hits(row.text) || (row.correction && this.#privacy.hits(row.correction))) memories += 1;
+    }
     return { entries, memories };
   }
 
@@ -334,13 +341,17 @@ export class RoomMemory {
     if (!this.#privacy?.enabled) return { entries: 0, memories: 0 };
     const counts = { entries: 0, memories: 0 };
     const entryRows = this.#db.prepare('SELECT sequence, event_id, timestamp, type, role, sender, target, message_id, text, distilled FROM entries').all();
-    const memoryRows = this.#db.prepare('SELECT id, created, kind, text, norm, from_sequence, through_sequence, sources, agent, origin, message_id FROM memories').all();
+    // Preserve every column when replacing a row. In particular, a refuted note must keep its
+    // standing and its refutation; a recall must keep its history. The schema is the source of
+    // this list so a later additive column cannot silently be reset to its default here.
+    const memoryColumns = this.#db.prepare('PRAGMA table_info(memories)').all().map((column) => column.name);
+    const memoryRows = this.#db.prepare('SELECT * FROM memories').all();
     const deleteEntry = this.#db.prepare('DELETE FROM entries WHERE sequence = ?');
     const deleteEntryVector = this.#db.prepare('DELETE FROM entry_vectors WHERE sequence = ?');
     const insertEntry = this.#db.prepare('INSERT INTO entries (sequence, event_id, timestamp, type, role, sender, target, message_id, text, distilled) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)');
     const deleteMemory = this.#db.prepare('DELETE FROM memories WHERE id = ?');
     const deleteMemoryVector = this.#db.prepare('DELETE FROM memory_vectors WHERE id = ?');
-    const insertMemory = this.#db.prepare('INSERT INTO memories (id, created, kind, text, norm, from_sequence, through_sequence, sources, agent, origin, message_id) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)');
+    const insertMemory = this.#db.prepare(`INSERT INTO memories (${memoryColumns.map((name) => `"${name.replaceAll('"', '""')}"`).join(', ')}) VALUES (${memoryColumns.map(() => '?').join(', ')})`);
     this.#db.exec('BEGIN');
     try {
       for (const row of entryRows) {
@@ -353,12 +364,14 @@ export class RoomMemory {
       }
       for (const row of memoryRows) {
         const { text, hits } = this.#privacy.redact(row.text);
-        if (!hits) continue;
+        const correction = row.correction ? this.#privacy.redact(row.correction) : { text: null, hits: 0 };
+        if (!hits && !correction.hits) continue;
         deleteMemoryVector.run(row.id);
         deleteMemory.run(row.id);
         // Two notes may collapse into the same redacted sentence: the later one is dropped.
-        const clash = this.#db.prepare('SELECT id FROM memories WHERE norm = ?').get(normalizeMemory(text));
-        if (!clash) insertMemory.run(row.id, row.created, row.kind, text, normalizeMemory(text), row.from_sequence, row.through_sequence, row.sources, row.agent, row.origin, row.message_id);
+        const norm = memoryKey(row.kind, text);
+        const clash = this.#db.prepare('SELECT id FROM memories WHERE norm = ?').get(norm);
+        if (!clash) insertMemory.run(...memoryColumns.map((name) => name === 'text' ? text : name === 'norm' ? norm : name === 'correction' ? correction.text : row[name]));
         counts.memories += 1;
       }
       this.#db.exec('COMMIT');
@@ -610,9 +623,13 @@ export class RoomMemory {
     if (!row) return null;
     this.#db.exec('BEGIN');
     try {
-      this.#db.prepare(`UPDATE memories SET refuted_by = NULL, zone = '${HOLD}' WHERE refuted_by = ?`).run(row.id);
+      // What it took out stands again by the rule, the human's verdict included (LOG-10 of the
+      // 1.0 review): written straight to HOLD, a note the human had marked bad travelled again.
+      const freed = this.#db.prepare('SELECT id FROM memories WHERE refuted_by = ?').all(row.id).map((one) => one.id);
+      this.#db.prepare('UPDATE memories SET refuted_by = NULL WHERE refuted_by = ?').run(row.id);
       this.#db.prepare('DELETE FROM memories WHERE id = ?').run(row.id);
       this.#db.prepare('DELETE FROM memory_vectors WHERE id = ?').run(row.id);
+      this.#restand(freed);
       this.#db.exec('COMMIT');
       return { id: row.id, text: row.text, restored: row.contradicts ?? null };
     } catch (error) {
@@ -666,18 +683,27 @@ export class RoomMemory {
       this.#db.prepare('DELETE FROM recalls WHERE memory_id = ?').run(id);
       // A note quarantined by this one comes back: with the aberration gone there is nothing
       // holding it out of circulation, and a memory must never be lost to a pointer at nothing.
-      this.#db.prepare(`UPDATE memories SET refuted_by = NULL, zone = '${HOLD}' WHERE refuted_by = ?`).run(id);
+      // Where it stands is decided by the rule, the human's verdict included (LOG-10).
+      const freed = this.#db.prepare('SELECT id FROM memories WHERE refuted_by = ?').all(id).map((one) => one.id);
+      this.#db.prepare('UPDATE memories SET refuted_by = NULL WHERE refuted_by = ?').run(id);
       this.#db.prepare('DELETE FROM memories WHERE id = ?').run(id);
+      this.#restand(freed);
       this.#db.exec('COMMIT');
     } catch (error) { this.#db.exec('ROLLBACK'); throw error; }
     return row;
   }
 
   // Which notes are about the same thing: pairs whose vectors agree, strongest
-  // first, a few per note. Empty without an embedder or vectors.
+  // first, a few per note. Comparing notes with each other needs only the vectors
+  // already stored, not a live embedder: when the one in use has none (Ollama off,
+  // the room fell back to another), the model that embedded the most notes draws
+  // the links. Empty only when no note was ever embedded.
   memoryLinks({ floor = 0.6, maxPerNode = 4 } = {}) {
-    if (!this.#embedder) return [];
-    const rows = this.#db.prepare('SELECT id, vec FROM memory_vectors WHERE model = ?').all(this.#embedder.model).map((row) => ({ id: row.id, vec: fromBlob(row.vec) }));
+    const stored = this.#db.prepare('SELECT model, COUNT(*) AS n FROM memory_vectors GROUP BY model ORDER BY n DESC').all();
+    const current = this.#embedder ? stored.find((row) => row.model === this.#embedder.model) : null;
+    const model = current?.model ?? stored[0]?.model;
+    if (!model) return [];
+    const rows = this.#db.prepare('SELECT id, vec FROM memory_vectors WHERE model = ?').all(model).map((row) => ({ id: row.id, vec: fromBlob(row.vec) }));
     const links = [];
     for (let i = 0; i < rows.length; i += 1) {
       for (let j = i + 1; j < rows.length; j += 1) {

package/src/models.mjs

@@ -26,6 +26,55 @@ export const KNOWN_MODELS = {
   },
 };
 
+// How hard the model thinks before it answers, for the CLIs that take it per run. Claude Code
+// reads --effort; Codex reads model_reasoning_effort as a config override. Gemini and OpenCode
+// have no per-run knob MADRE can name truthfully (OpenCode's --variant means something different
+// for each provider), so they get no chooser at all rather than one that guesses.
+//
+// Ordered lightest first: the composer draws them as a ladder, and the order is the meaning.
+//
+// Codex's levels belong to each model, not to the CLI. Its own cache (~/.codex/models_cache.json)
+// lists the ones each model takes, and the API refuses any other with a 400 — «'minimal' is not
+// supported with the 'gpt-5.5' model» — that used to reach the room as a lone «{». The list here is
+// every name Codex has used, in order; a turn gets only the ones its model takes.
+export const EFFORTS = {
+  claude: ['low', 'medium', 'high', 'xhigh', 'max'],
+  codex: ['minimal', 'low', 'medium', 'high', 'xhigh', 'max', 'ultra'],
+};
+// What a Codex with no cache to read is offered: the levels its models have always taken.
+const CODEX_SAFE = ['low', 'medium', 'high'];
+
+export function isValidEffort(agentId, effort) {
+  return typeof effort === 'string' && (EFFORTS[agentId] ?? []).includes(effort);
+}
+
+// Whose model a name is, when the name says so. Codex, Claude and Gemini each answer only to their
+// own vendor's models, and a name from another one reaches the CLI as an API error that reads
+// like anything but "wrong model" (Gemini: `models/gpt-5.6-sol is not found for API version
+// v1beta`). OpenCode is left out on purpose: it speaks to many providers, so any name may be its.
+const VENDOR = [
+  ['codex', /^(gpt-|o\d|codex-|chatgpt-)/i],
+  ['claude', /^(claude|fable|opus|sonnet|haiku)\b/i],
+  ['gemini', /^(gemini|gemma|auto$)/i],
+];
+export function modelOwner(model) {
+  return VENDOR.find(([, pattern]) => pattern.test(String(model ?? '')))?.[0] ?? null;
+}
+// True when the name clearly belongs to another of the three: the turn is better off on the
+// agent's own default than sent to fail.
+export function belongsElsewhere(agentId, model) {
+  if (!VENDOR.some(([id]) => id === agentId)) return false;
+  const owner = modelOwner(model);
+  return Boolean(owner) && owner !== agentId;
+}
+
+// A CLI saying it does not know the model it was given, in any of the ways the four say it.
+export const MODEL_NOT_FOUND = /models?\/\S+ is not found|not supported for generateContent|model[_ ]not[_ ]found|unknown model|invalid model|model (?:\S+ )?(?:does not exist|is not available|not found)|issue with the selected model/i;
+
+export function parseCodexDefaultEffort(toml) {
+  return String(toml ?? '').match(/^\s*model_reasoning_effort\s*=\s*"([^"]+)"/m)?.[1] ?? null;
+}
+
 export function parseCodexModelCache(json) {
   try {
     const data = JSON.parse(json);
@@ -42,6 +91,49 @@ export function parseCodexModelCache(json) {
   }
 }
 
+// Per model, the efforts it takes (lightest first) and the one it uses when told nothing.
+export function parseCodexEfforts(json) {
+  try {
+    const data = JSON.parse(json);
+    const byModel = {};
+    const walk = (node) => {
+      if (!node || typeof node !== 'object') return;
+      if (typeof node.slug === 'string' && Array.isArray(node.supported_reasoning_levels)) {
+        const levels = EFFORTS.codex.filter((level) => node.supported_reasoning_levels.some((one) => one?.effort === level));
+        if (levels.length) byModel[node.slug] = { levels, default: levels.includes(node.default_reasoning_level) ? node.default_reasoning_level : null };
+      }
+      for (const value of Object.values(node)) walk(value);
+    };
+    walk(data);
+    return byModel;
+  } catch {
+    return {};
+  }
+}
+
+// The levels one Codex model takes: its own, from the cache; for a name the cache does not list,
+// the ones every listed model shares, so a model MADRE cannot read never meets a refusal.
+export function codexLevels(byModel, model) {
+  if (model && byModel[model]) return byModel[model].levels;
+  const lists = Object.values(byModel).map((one) => one.levels);
+  return lists.length ? lists.reduce((shared, levels) => shared.filter((level) => levels.includes(level))) : CODEX_SAFE;
+}
+
+export async function readCodexEfforts({ home = homedir() } = {}) {
+  const [cache, toml] = await Promise.all([
+    readFile(join(home, '.codex', 'models_cache.json'), 'utf8').catch(() => ''),
+    readFile(join(home, '.codex', 'config.toml'), 'utf8').catch(() => ''),
+  ]);
+  return { byModel: parseCodexEfforts(cache), model: parseCodexDefaultModel(toml), effort: parseCodexDefaultEffort(toml) };
+}
+
+// Whether a turn's effort reaches Codex: the model it runs on — the one chosen, or the CLI's
+// default — has to take it.
+export async function codexTakes(model, effort, { home = homedir() } = {}) {
+  const read = await readCodexEfforts({ home });
+  return codexLevels(read.byModel, model || read.model).includes(effort);
+}
+
 export function parseCodexDefaultModel(toml) {
   return String(toml ?? '').match(/^\s*model\s*=\s*"([^"]+)"/m)?.[1] ?? null;
 }
@@ -58,9 +150,22 @@ export async function discoverModels({ agents = [], config = {}, home = homedir(
     const known = KNOWN_MODELS[agent.id] ?? { defaults: [], note: '' };
     let discovered = [];
     let cliDefault = null;
+    let effortDefault = null;
+    let efforts = EFFORTS[agent.id] ?? [];
+    let effortsByModel;
+    let effortsShared;
     if (agent.id === 'codex') {
       discovered = parseCodexModelCache(await readFile(join(home, '.codex', 'models_cache.json'), 'utf8').catch(() => ''));
-      cliDefault = parseCodexDefaultModel(await readFile(join(home, '.codex', 'config.toml'), 'utf8').catch(() => ''));
+      const read = await readCodexEfforts({ home });
+      cliDefault = read.model;
+      effortDefault = read.effort;
+      // The ladder is the model's: the CLI default's here, each model's in the composer once it is
+      // chosen. What the CLI does when told nothing is the config's level if that model takes it,
+      // or the model's own.
+      efforts = codexLevels(read.byModel, cliDefault);
+      effortsShared = codexLevels(read.byModel, null);
+      effortsByModel = Object.fromEntries(Object.entries(read.byModel).map(([slug, one]) => [slug, { levels: one.levels, default: one.levels.includes(read.effort) ? read.effort : one.default }]));
+      if (!efforts.includes(effortDefault)) effortDefault = (cliDefault && read.byModel[cliDefault]?.default) || null;
     }
     if (agent.id === 'opencode' && agent.detected) {
       discovered = await listOpenCode(agent).catch(() => []);
@@ -71,6 +176,9 @@ export async function discoverModels({ agents = [], config = {}, home = homedir(
       models: unique([...custom, ...discovered, ...known.defaults]),
       default: cliDefault,
       note: known.note,
+      efforts,
+      effortDefault: isValidEffort(agent.id, effortDefault) ? effortDefault : null,
+      ...(effortsByModel ? { effortsByModel, effortsShared } : {}),
       source: discovered.length ? 'discovered' : 'known',
     };
   }

package/src/modules/ahp.mjs

@@ -30,12 +30,12 @@ async function detect(projectRoot) {
 async function preflight(projectRoot, { toplevel = gitToplevel, npx = findOnPath } = {}) {
   const root = await realpath(projectRoot).catch(() => resolve(projectRoot));
   const problems = [];
-  if (!(await npx('npx'))) problems.push('npx is not on PATH for the MADRE server; start MADRE from a terminal where `npx --version` works.');
+  if (!(await npx('npx'))) problems.push(t('npx is not on PATH for the MADRE server; start MADRE from a terminal where `npx --version` works.'));
   const top = await toplevel(root);
   if (!top) {
-    problems.push('The project is not a git repository. AHP+ pins itself to the git root: run `git init` in the project first.');
+    problems.push(t('The project is not a git repository. AHP+ pins itself to the git root: run `git init` in the project first.'));
   } else if (top !== root) {
-    problems.push(`The project's git root is ${top}, not the project itself. AHP+ would install there. Run \`git init\` inside the project, or remove the stray repository at ${top}.`);
+    problems.push(t('The project\'s git root is {top}, not the project itself. AHP+ would install there. Run `git init` inside the project, or remove the stray repository at {top}.', { top }));
   }
   return { ok: problems.length === 0, problems, gitRoot: top };
 }
@@ -50,7 +50,7 @@ function installCommand({ agents = [] }) {
 export default defineModule({
   id: 'ahp',
   kind: 'installer',
-  name: 'AHP+',
+  name: 'Continuity',
   vendor: 'Agent Handoff Protocol Plus',
   package: PACKAGE,
   tracks: { name: PACKAGE, npm: PACKAGE },

package/src/modules/ash.mjs

@@ -20,7 +20,7 @@ import { t } from '../i18n.mjs';
 export default defineModule({
   id: 'ash',
   configKey: 'ash',
-  name: 'Ash',
+  name: 'Token saver',
   vendor: 'MADRE',
   version: '1.0.0',
   summary: 'Asks every agent for compact prose without altering what you write. MADRE shows each turn\'s input, output and cache use; savings depend on the agent, task and cache, so no fixed percentage is promised.',