@jossuealcala/madre 1.0.2 → 1.0.3

package/src/modules/bishop.mjs

@@ -27,6 +27,8 @@ import { BISHOP_SIGN_DAYS, CHANNEL_HEADER, MAX_ORDER_MODE, NO_SUCH_LINK, activeC
 import { t } from '../i18n.mjs';
 import { askRoom, ensureSalasProject, isSalasRoom, knownRooms, projectRoomId, roomComesUp, salasRoomId, startRoom } from '../salas.mjs';
 import { defineModule } from './sdk.mjs';
+import { ollamaGenerate, ollamaHost } from '../ollama.mjs';
+import { LOCAL_ORDER_MODE, buildExam, examHolds, examPairs, keepExam, readExam, runExam } from './bishop-exam.mjs';
 import {
   BISHOP_MODES, CONSULT_HEADER, MAX_ORDERS, ORDER_CHARS, ORDER_HEADER, PLAN_FENCE, RESULT_CHARS, changePlans, clean, closing, consultHeader,
   newPlanId, orderHeader, parsePlan, planById, publicLink, publicOrder, resolveLinks, resolveOrder, resolveOrders,
@@ -57,6 +59,18 @@ const SIGNER_WORDS = { bishop: 'The Coordinator signs connections to read', you:
 const signerOf = (ctx) => (ctx.config?.modules?.bishop?.links === 'you' ? 'you' : 'bishop');
 // S-030: @madre as BISHOP only answers. It is still the human's choice of who BISHOP is.
 export const onlyAnswers = (agent) => agent === 'madre';
+// D-S18: unless the local model it answers with passed the exam (src/modules/bishop-exam.mjs), and
+// it is still that very model. Then it gives orders up to #1 and proposes no connections.
+const localModel = (ctx) => {
+  const probe = ctx.services?.ollama?.state?.() ?? null;
+  const name = probe?.madreModel ?? probe?.chatModel ?? null;
+  return name ? { name, digest: (probe.models ?? []).find((model) => model.name === name)?.digest ?? null } : null;
+};
+async function answersOnlyNow(ctx, agent) {
+  if (!onlyAnswers(agent)) return false;
+  return !examHolds(await readExam(ctx.stateRoot).catch(() => null), localModel(ctx));
+}
+let examining = null;
 const reply = (status, body) => ({ status, body });
 
 /* ---------- the channel ---------- */
@@ -120,6 +134,7 @@ async function sendOrder(ctx, planId, step, { auto = false } = {}) {
   if (!contract) return back(404, t('No signed connection lets the Coordinator give orders to that project.'));
   const ceiling = Math.min(contract.orders.maxMode, MAX_ORDER_MODE);
   if (order.mode > ceiling) return back(403, t('That connection allows orders up to #{n}.', { n: ceiling }));
+  if (onlyAnswers(plan.agent) && (order.mode > LOCAL_ORDER_MODE || await answersOnlyNow(ctx, plan.agent))) return back(403, t('The Coordinator\'s local model gives orders up to #1, and only after passing its exam.'));
   const target = (await knownRooms(ctx.stateRoot)).find((room) => room.id === order.room);
   if (!target?.open) return back(409, t('That project is asleep. Wake it from Home to send it orders.'));
   const key = await channelKey(ctx.stateRoot).catch(() => null);
@@ -159,7 +174,7 @@ async function deliverProposal(ctx, planId, step, { auto = false } = {}) {
 // proposal that cannot leave on its own is held: it says why and waits for the human's press.
 async function advance(ctx, planId) {
   const plan = await planById(ctx.stateRoot, planId);
-  if (!plan || plan.halted || onlyAnswers(plan.agent)) return;
+  if (!plan || plan.halted || await answersOnlyNow(ctx, plan.agent)) return;
   const hold = async (order, why) => {
     await changePlans(ctx.stateRoot, (data) => { const one = data.plans[plan.id]?.orders.find((item) => item.step === order.step); if (one) one.held = why; });
     await ctx.services.recordIn(plan.chat, 'bishop.order.held', { plan: plan.id, step: order.step, why });
@@ -170,7 +185,7 @@ async function advance(ctx, planId) {
     if (delivered.status !== 202) await hold(order, delivered.body.error);
   }
   if (plan.mode === 'manual') return;
-  const ceiling = plan.mode === 'auto' ? 2 : 1;
+  const ceiling = Math.min(plan.mode === 'auto' ? 2 : 1, onlyAnswers(plan.agent) ? LOCAL_ORDER_MODE : 2);
   const busy = new Set(plan.orders.filter((order) => ['sending', 'sent'].includes(order.status)).map((order) => order.room));
   for (const order of plan.orders) {
     if (order.status !== 'ready' || order.held || order.mode > ceiling || busy.has(order.room)) continue;
@@ -243,7 +258,8 @@ const base = defineModule({
     // which the card's translation (exact sentences only) could never match.
     const detail = !ctx.settings.enabled ? t('off')
       : !agent ? t('No ready agent. Choose one when it is available.')
-      : onlyAnswers(agent) ? t('on · @{agent} · only answers', { agent })
+      : await answersOnlyNow(ctx, agent) ? t('on · @{agent} · only answers', { agent })
+      : onlyAnswers(agent) ? t('on · @{agent} · passed its exam: orders up to #1', { agent })
       : t('on · @{agent} · {orders} · {links}', { agent, orders: t(ORDER_WORDS[modeOf(ctx)]), links: t(SIGNER_WORDS[signerOf(ctx)]) });
     return { status: { installed: Boolean(ctx.settings.enabled && agent), detail } };
   },
@@ -293,8 +309,13 @@ const base = defineModule({
     }
     if (event?.type !== 'message.created') return;
     if (said.role !== 'assistant' || said.status !== 'completed' || said.target !== 'you' || said.planId || said.synthetic || said.sender !== chosen(ctx)) return;
-    if (relayed.has(said.parentMessageId) || onlyAnswers(said.sender)) return;
+    if (relayed.has(said.parentMessageId) || await answersOnlyNow(ctx, said.sender)) return;
     const parsed = parsePlan(said.text);
+    // D-S18: a local model that passed its exam gives orders up to #1 and never proposes connections.
+    if (parsed && onlyAnswers(said.sender)) {
+      for (const link of parsed.links) parsed.ignored.push({ line: `${link.from} → ${link.to}`, why: 'the local model proposes no connections' });
+      parsed.links = [];
+    }
     if (!parsed) return;
     if (!parsed.orders.length && !parsed.links.length) {
       await ctx.record('bishop.plan.ignored', { responseMessageId: said.messageId, agent: said.sender, reasons: parsed.ignored.map((item) => item.why) });
@@ -303,7 +324,8 @@ const base = defineModule({
     const salas = salasRoomId(ctx.stateRoot);
     const rooms = await knownRooms(ctx.stateRoot);
     const contracts = activeContracts(ctx.config, { salas });
-    const orders = resolveOrders({ orders: parsed.orders, rooms, contracts, salas, agents: ctx.agents });
+    const orders = resolveOrders({ orders: parsed.orders, rooms, contracts, salas, agents: ctx.agents })
+      .map((order) => (onlyAnswers(said.sender) && order.mode > LOCAL_ORDER_MODE && ['ready', 'proposal'].includes(order.status) ? { ...order, status: 'blocked', why: 'The Coordinator\'s local model gives orders up to #1.' } : order));
     const links = resolveLinks({ links: parsed.links, rooms, contracts, salas });
     const plan = { id: newPlanId(), chat: ctx.chat ?? null, responseMessageId: said.messageId, agent: said.sender, reason: parsed.reason, mode: modeOf(ctx), createdAt: new Date().toISOString(), closed: false, halted: null, orders, links, asked: parsed.orders };
     await changePlans(ctx.stateRoot, (data) => { data.plans[plan.id] = plan; });
@@ -318,6 +340,31 @@ const base = defineModule({
     await advance(ctx, plan.id);
   },
   routes: [
+    // D-S18 · the exam of the local model, from the page of Home: started here, run in the
+    // background (a local model is slow), its result kept beside the room and recorded.
+    { method: 'GET', path: '/api/x/bishop/exam', handler: async (ctx, { viaPhone }) => pageDoor(ctx, viaPhone) ?? reply(200, { exam: await readExam(ctx.stateRoot), running: Boolean(examining), model: localModel(ctx), holds: examHolds(await readExam(ctx.stateRoot), localModel(ctx)) }) },
+    { method: 'POST', path: '/api/x/bishop/exam', handler: async (ctx, { viaPhone }) => {
+      const refused = pageDoor(ctx, viaPhone);
+      if (refused) return refused;
+      if (examining) return reply(409, { error: t('The exam is already running.') });
+      const model = localModel(ctx);
+      if (!model) return reply(412, { error: t('Local AI has no chat model to examine. Download one in Local AI, or train the Coordinator\'s.') });
+      const salas = salasRoomId(ctx.stateRoot);
+      const rooms = await knownRooms(ctx.stateRoot);
+      const contracts = activeContracts(ctx.config, { salas });
+      const ordering = contracts.map((contract) => receivesOrders(contract, salas)).filter(Boolean).map((id) => rooms.find((room) => room.id === id)).filter(Boolean);
+      const cases = buildExam({ ...(await examPairs(join(ctx.stateRoot, 'rooms', salas, 'dataset'))), rooms, ordering });
+      const where = { rooms, contracts, salas, agents: ctx.agents };
+      const crew = readyAgents(ctx).map((one) => one.id);
+      const system = (kind) => formatBishop({ rooms, contracts, links: readsFrom(contracts, salas), local: true, salas, crew, answersOnly: kind === 'answer', localOrders: kind === 'order', signer: 'you' });
+      const ask = async (prompt, question) => (await ollamaGenerate({ host: ollamaHost(), model: model.name, system: prompt, prompt: question, timeoutMs: 120000, temperature: 0.1 })).text;
+      await ctx.record('bishop.exam.started', { model: model.name, known: cases.known.length, unknown: cases.unknown.length, orders: cases.orders.length });
+      examining = runExam({ model, cases, ask, system, where })
+        .then(async (result) => { await keepExam(ctx.stateRoot, result); await ctx.record('bishop.exam.finished', { model: result.model, passed: result.passed, scores: result.scores, why: result.why }); })
+        .catch(async (error) => { await ctx.record('bishop.exam.failed', { model: model.name, error: String(error.message).slice(0, 300) }); })
+        .finally(() => { examining = null; });
+      return reply(202, { started: true, model: model.name, cases: { known: cases.known.length, unknown: cases.unknown.length, orders: cases.orders.length } });
+    } },
     // The human pressed «Send» on one order of a plan, in the page of Salas.
     { method: 'POST', path: '/api/x/bishop/send', handler: async (ctx, { payload, viaPhone }) => pageDoor(ctx, viaPhone) ?? sendOrder(ctx, payload?.plan, payload?.step) },
     // «Take it to its room»: a #3/#4 proposal, for the human to arm there.
@@ -524,13 +571,13 @@ const bishop = Object.freeze({
       choices: agents.map((one) => ({ value: one.id, label: onlyAnswers(one.id) ? '@madre · only answers' : `@${one.id}` })),
       note: 'The ready agent the Coordinator speaks through. With @madre, the Coordinator only answers: it proposes neither orders nor connections.',
     }] : [];
-    if (agent && !onlyAnswers(agent)) {
+    if (agent && !(await answersOnlyNow(ctx, agent))) {
       controls.push({
         key: 'mode', label: 'ORDERS', type: 'select', options: BISHOP_MODES, value: modeOf(ctx),
         choices: BISHOP_MODES.map((value) => ({ value, label: ORDER_CHOICES[value] })),
         note: 'Always within what the connection allows. #3 and #4 always wait for your confirmation in their project; an error or STOP ALL halts the orders that go out on their own.',
       });
-      controls.push({
+      if (!onlyAnswers(agent)) controls.push({
         key: 'links', label: 'CONNECTIONS TO READ', type: 'select', options: LINK_SIGNERS, value: signerOf(ctx),
         choices: LINK_SIGNERS.map((value) => ({ value, label: SIGNER_CHOICES[value] })),
         note: 'A connection with orders is always signed by you. A connection the Coordinator signed is revoked with one press, in Home.',
@@ -562,7 +609,7 @@ const bishop = Object.freeze({
 export default bishop;
 
 // Pure formatting makes the 1500-character ceiling inspectable. Names are data, never orders.
-export function formatBishop({ rooms, glances = new Map(), contracts = [], links = [], notes = [], unread = [], local = false, salas = null, crew = [], answersOnly = false, signer = 'bishop' }) {
+export function formatBishop({ rooms, glances = new Map(), contracts = [], links = [], notes = [], unread = [], local = false, salas = null, crew = [], answersOnly = false, signer = 'bishop', localOrders = false }) {
   const names = new Map(rooms.map((room) => [room.id, clean(room.name, 40)]));
   const lead = 'BISHOP: guardián de las salas. Responde sobre proyectos, decisiones y movimientos; cita siempre la sala de cada hecho. Si una sala no se pudo leer, dilo. Nunca muevas un proyecto por dentro.';
   const ordering = contracts.filter((contract) => receivesOrders(contract, salas));
@@ -571,8 +618,18 @@ export function formatBishop({ rooms, glances = new Map(), contracts = [], links
   const unlinked = rooms.filter((room) => room.id !== salas && !linked.has(room.id));
   const never = 'Nunca pidas llaves, propongas publicar ni nombres rutas privadas.';
   let end;
-  if (answersOnly) end = `Solo consulta: responde y cita la sala de cada dato; di qué no pudiste leer. Sin bloques de órdenes ni de enlaces. ${never}`;
-  else {
+  if (answersOnly) end = `Solo consulta: responde y cita la sala de cada dato; di qué no pudiste leer; si ninguna sala lo discutió, dilo. Sin bloques de órdenes ni de enlaces. ${never}`;
+  else if (localOrders) {
+    // D-S18: the local model that passed its exam — orders up to #1, the shape shown with a room and
+    // an agent that are really here, and no connections.
+    const sample = ordering.length ? (names.get(receivesOrders(ordering[0], salas)) ?? receivesOrders(ordering[0], salas)) : 'sala';
+    const helper = crew.find((id) => id !== 'madre') ?? crew[0] ?? 'codex';
+    end = [
+      'Si el humano pide una orden, cierra tu respuesta con este bloque, y nada después:',
+      `\`\`\`${PLAN_FENCE}`, 'Motivo del plan en una línea', `@${sample}/${helper} #1: la tarea, en una frase`, '```',
+      `Órdenes: hasta 4, «@sala/agente #0-#1: tarea», solo a salas con órdenes${crew.length ? `; agentes: ${crew.join(', ')}` : ''}. Nunca a una sala que no está en los contratos. Sin enlaces. ${never}`,
+    ].join('\n');
+  } else {
     // A small model copies a placeholder word for word («@sala/agente»), so the shape is shown with
     // rooms that are really there and an agent that is really here.
     const sample = ordering.length ? (names.get(receivesOrders(ordering[0], salas)) ?? receivesOrders(ordering[0], salas)) : null;
@@ -591,7 +648,7 @@ export function formatBishop({ rooms, glances = new Map(), contracts = [], links
     const a = names.get(contract.rooms.a) ?? clean(contract.rooms.a, 40);
     const b = names.get(contract.rooms.b) ?? clean(contract.rooms.b, 40);
     const receives = receivesOrders(contract, salas);
-    lines.push(`- ${a} ${contract.direction} ${b}; lee:${contract.kinds.map((kind) => clean(kind, 12)).join(',')}; órdenes:${receives ? `a ${names.get(receives) ?? clean(receives, 40)} hasta #${Math.min(contract.orders.maxMode, MAX_ORDER_MODE)}` : 'no'}`);
+    lines.push(`- ${a} ${contract.direction} ${b}; lee:${contract.kinds.map((kind) => clean(kind, 12)).join(',')}; órdenes:${receives ? `a ${names.get(receives) ?? clean(receives, 40)} hasta #${Math.min(contract.orders.maxMode, MAX_ORDER_MODE)}` : 'no'}${contract.state ? '; estado:sí' : ''}${contract.deliver ? '; entrega:sí' : ''}`);
   }
   if (!contracts.length) lines.push('- ninguno');
   lines.push(`Lectura para esta sala: ${links.map(({ from }) => names.get(from) ?? clean(from, 40)).join(', ') || 'ninguna'}. Solo notas con contrato firmado; ${local ? 'las notas disponibles para esta pregunta van abajo' : 'usa pulse-enlaces para buscar'} y cita la sala.`);
@@ -643,5 +700,7 @@ export async function bishopBlock(ctx, { agent, text = '', mode = 1, preview = f
       else unread.push({ room: source.name, why: answer.status === 429 ? 'tope de lecturas por hora' : answer.status === 423 ? 'archivo sellado' : 'no respondió' });
     }
   }
-  return formatBishop({ rooms, glances, contracts, links, notes: notes.slice(0, MAX_NOTES), unread, local: agent === 'madre', salas, crew: readyAgents(ctx).map((one) => one.id), answersOnly: onlyAnswers(agent) || CONSULT_HEADER.test(text), signer: signerOf(ctx) });
+  const consult = CONSULT_HEADER.test(text);
+  const answersOnly = consult || await answersOnlyNow(ctx, agent);
+  return formatBishop({ rooms, glances, contracts, links, notes: notes.slice(0, MAX_NOTES), unread, local: agent === 'madre', salas, crew: readyAgents(ctx).map((one) => one.id), answersOnly, localOrders: !answersOnly && onlyAnswers(agent), signer: signerOf(ctx) });
 }

package/src/modules/enlaces.mjs

@@ -22,19 +22,21 @@ import { realpath } from 'node:fs/promises';
 import { basename, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { loadConfig } from '../config.mjs';
-import { CHANNEL_HEADER, DAY_MS, LINK_KINDS, MAX_LIMIT, RECALL_NOTES, activeContracts, askEnlace, channelKey, countRecent, readsFrom } from '../enlaces.mjs';
+import { CHANNEL_HEADER, DAY_MS, DELIVER_CHARS, DELIVER_MAX, LINK_KINDS, MAX_LIMIT, RECALL_NOTES, activeContracts, askEnlace, channelKey, countRecent, deliversTo, readInbox, readsFrom } from '../enlaces.mjs';
+import { continuityText } from './ahp.mjs';
 import { t } from '../i18n.mjs';
 import { knownRooms, projectRoomId, salasRoomId } from '../salas.mjs';
 import { defineModule } from './sdk.mjs';
+import { moduleOnIn } from '../module-scope.mjs';
 
 const SELF = fileURLToPath(import.meta.url);
 export const SERVER_NAME = 'pulse-enlaces';
 export const SERVER_VERSION = '0.1.0';
-export const ENLACE_TOOLS = ['enlace_rooms', 'enlace_search'];
+export const ENLACE_TOOLS = ['enlace_rooms', 'enlace_search', 'enlace_state', 'enlace_deliver', 'enlace_inbox', 'enlace_accept'];
 
 // What the agent is told of the server, in the language every brief is written in. Read-only is
 // said twice on purpose: once as a fact, once as what to do with it.
-export const BRIEF = 'Distilled notes of other rooms on this Mac that a signed link lets this room read (MCP server pulse-enlaces). Read-only: nothing you write here reaches those rooms, and nothing of theirs enters this room unless you ask for it. enlace_rooms says which rooms you may read and which kinds of notes; enlace_search reads them. Say where each borrowed note comes from, as in «according to room <name>».';
+export const BRIEF = 'Distilled notes of other rooms on this Mac that a signed link lets this room read (MCP server pulse-enlaces). Read-only when you read: nothing you read writes in those rooms, and nothing of theirs enters this room unless you ask for it. enlace_rooms says which rooms you may read, which kinds of notes, and what else each link allows; enlace_search reads notes; enlace_state reads a room\'s canonical state (Continuity) when its link shares it. Where a link allows deliveries, enlace_deliver hands a few notes to that room, where they wait until that room accepts them. enlace_inbox lists the notes other rooms delivered here; enlace_accept accepts or declines one, only in #3 or #4. Say where each borrowed note comes from, as in «according to room <name>».';
 
 // The links that let a room read, from the config every room on this Mac shares.
 const linksFor = (config, stateRoot, here, now = new Date()) => readsFrom(activeContracts(config, { now, salas: salasRoomId(stateRoot) }), here, { now });
@@ -78,7 +80,9 @@ export default defineModule({
   async toolsForTurn(ctx, turn) {
     if (!(Number(turn?.mode) >= 1) || !turn?.roomDir || !turn?.port || !ctx.stateRoot) return [];
     const here = basename(turn.roomDir);
-    if (!linksFor(ctx.config, ctx.stateRoot, here).length) return [];
+    // A room with notes delivered to it gets the tools too, to read them and, in #3/#4, decide them.
+    const waiting = (await readInbox(turn.roomDir).catch(() => [])).some((note) => note.status === 'pending');
+    if (!linksFor(ctx.config, ctx.stateRoot, here).length && !waiting) return [];
     return [{
       name: SERVER_NAME,
       command: process.execPath,
@@ -99,8 +103,9 @@ export default defineModule({
 // hourly limit, a sealed archive or a room asleep simply brings nothing this turn.
 export async function recallForTurn(ctx, { agent = null, mode = 1, text = '', turn = null, preview = false, roomDir = null, record = null } = {}) {
   if (!(Number(mode) >= 1) || !ctx?.stateRoot || !roomDir) return null;
-  if (ctx.config?.modules?.enlaces?.enabled === false) return null;
   const here = basename(roomDir);
+  // Off in this project, or for every project and not turned on here (module-scope.mjs).
+  if (!moduleOnIn(ctx.config?.modules?.enlaces ?? {}, here, true)) return null;
   const links = linksFor(ctx.config, ctx.stateRoot, here).filter(({ contract }) => contract.recall);
   if (!links.length) return null;
   if (preview) return { text: null, dynamic: true };
@@ -140,6 +145,29 @@ export const TOOLS = [
       limit: { type: 'integer', description: 'Max notes (1-20, default 20).' },
     }, required: ['room'] },
   },
+  {
+    name: 'enlace_state',
+    description: 'Read the canonical state of another room — objective, phase, next action, blockers, its last handoff, accepted decisions and what is still open — as Continuity (AHP+) keeps it there, when the link shares it. Read-only, through that room\'s privacy guard. Cite it as that room\'s state on its date.',
+    inputSchema: { type: 'object', properties: { room: { type: 'string', description: 'The room, by its name as enlace_rooms lists it.' } }, required: ['room'] },
+  },
+  {
+    name: 'enlace_deliver',
+    description: `Hand up to ${DELIVER_MAX} notes to a room this room reads from, when the link allows deliveries. Each note waits in that room until it is accepted there; nothing enters its memory by itself. Only knowledge that stands (decision, fact, preference, question), up to ${DELIVER_CHARS} characters each, with the reason in one line.`,
+    inputSchema: { type: 'object', properties: {
+      room: { type: 'string', description: 'The room, by its name as enlace_rooms lists it.' },
+      notes: { type: 'array', maxItems: DELIVER_MAX, items: { type: 'object', properties: { kind: { type: 'string', enum: LINK_KINDS }, text: { type: 'string' }, why: { type: 'string' } }, required: ['kind', 'text'] } },
+    }, required: ['room', 'notes'] },
+  },
+  {
+    name: 'enlace_inbox',
+    description: 'The notes other rooms delivered to this room that are still waiting: id, sender, kind, text and why. Read-only.',
+    inputSchema: { type: 'object', properties: {} },
+  },
+  {
+    name: 'enlace_accept',
+    description: 'Accept (or decline, with accept: false) one delivered note by its id. Accepted, it enters this room\'s memory as a new note, held first like any other. Only in #3 or #4; below that, the human decides.',
+    inputSchema: { type: 'object', properties: { id: { type: 'string' }, accept: { type: 'boolean' } }, required: ['id'] },
+  },
 ];
 
 function clamp(n, min, max, fallback) { const value = Number(n); return Number.isFinite(value) ? Math.min(max, Math.max(min, Math.trunc(value))) : fallback; }
@@ -161,7 +189,8 @@ export async function callTool(name, args = {}, { env = process.env, fetchImpl =
       return links.map(({ contract, from }) => {
         const room = rooms.find((one) => one.id === from) ?? null;
         const state = room?.open ? 'open' : room ? 'asleep (ask the human to wake it from Salas)' : 'not on this Mac any more';
-        return `- ${room?.name ?? from} · ${contract.kinds.join(', ')} · ${contract.expires ? `until ${contract.expires.slice(0, 10)}` : 'no expiry'} · ${state}`;
+        const also = [contract.state ? 'shares its state (enlace_state)' : null, contract.deliver ? 'accepts deliveries (enlace_deliver)' : null].filter(Boolean);
+        return `- ${room?.name ?? from} · ${contract.kinds.join(', ')} · ${contract.expires ? `until ${contract.expires.slice(0, 10)}` : 'no expiry'} · ${state}${also.length ? ` · ${also.join(' · ')}` : ''}`;
       }).join('\n');
     }
     case 'enlace_search': {
@@ -194,6 +223,58 @@ export async function callTool(name, args = {}, { env = process.env, fetchImpl =
       if (!notes.length) return `Room ${from} has no note${kinds.length ? ` of kind ${kinds.join(', ')}` : ''}${query ? ` that matches "${query}"` : ' that travels'} right now.`;
       return notes.map((note) => `- [${from} · ${note.kind} · ${note.zone} · ${span(note)}] ${note.text}`).join('\n');
     }
+    case 'enlace_state':
+    case 'enlace_deliver': {
+      const room = String(args.room ?? '').trim();
+      if (!room) return 'Say which room; enlace_rooms lists them.';
+      if (!stateRoot || !port) return 'This turn was started without a room: nothing can be read.';
+      const key = await channelKey(stateRoot).catch(() => null);
+      if (!key) return 'Nothing was done: this Mac has no key for its links.';
+      const sending = name === 'enlace_deliver';
+      const notes = sending ? (Array.isArray(args.notes) ? args.notes : []).slice(0, DELIVER_MAX).map((note) => ({ kind: String(note?.kind ?? ''), text: String(note?.text ?? ''), why: note?.why ? String(note.why) : null })) : null;
+      if (sending && !notes.length) return `Nothing was delivered: give between 1 and ${DELIVER_MAX} notes.`;
+      let response;
+      try {
+        response = await fetchImpl(`http://127.0.0.1:${port}${sending ? '/api/enlace/send' : '/api/enlace/ask-state'}`, {
+          method: 'POST',
+          headers: { 'content-type': 'application/json', [CHANNEL_HEADER]: key },
+          body: JSON.stringify({ room, notes, agent: env.PULSE_ENLACES_AGENT ?? null, turn: env.PULSE_ENLACES_TURN ?? null }),
+          signal: AbortSignal.timeout(timeoutMs),
+        });
+      } catch {
+        return `Nothing was ${sending ? 'delivered' : 'read'}: this room did not answer.`;
+      }
+      const answer = await response.json().catch(() => ({}));
+      if (!response.ok) return `Nothing was ${sending ? 'delivered' : 'read'}: ${typeof answer?.error === 'string' ? answer.error : `HTTP ${response.status}`}`;
+      const from = typeof answer?.from === 'string' && answer.from ? answer.from : typeof answer?.to === 'string' && answer.to ? answer.to : room;
+      if (sending) return `${answer.delivered} note${answer.delivered === 1 ? '' : 's'} delivered to room ${from}. They wait there until that room accepts them; nothing is in its memory yet.`;
+      return continuityText(from, answer.state) ?? `Room ${from} keeps no canonical state (Continuity is not installed there).`;
+    }
+    case 'enlace_inbox': {
+      if (!stateRoot || !here) return 'This turn was started without a room: nothing can be read.';
+      const pending = (await readInbox(join(stateRoot, 'rooms', here))).filter((note) => note.status === 'pending');
+      if (!pending.length) return 'No delivered note is waiting in this room.';
+      return pending.map((note) => `- ${note.id} · from ${note.name}${note.agent ? ` (@${note.agent})` : ''} · ${note.kind}: ${note.text}${note.why ? ` — why: ${note.why}` : ''}`).join('\n');
+    }
+    case 'enlace_accept': {
+      if (!port) return 'This turn was started without a room: nothing can be decided.';
+      const key = await channelKey(stateRoot).catch(() => null);
+      if (!key) return 'Nothing was decided: this Mac has no key for its links.';
+      let response;
+      try {
+        response = await fetchImpl(`http://127.0.0.1:${port}/api/enlace/inbox/decide`, {
+          method: 'POST',
+          headers: { 'content-type': 'application/json', [CHANNEL_HEADER]: key },
+          body: JSON.stringify({ id: String(args.id ?? ''), accept: args.accept !== false, agent: env.PULSE_ENLACES_AGENT ?? null, turn: env.PULSE_ENLACES_TURN ?? null }),
+          signal: AbortSignal.timeout(timeoutMs),
+        });
+      } catch {
+        return 'Nothing was decided: this room did not answer.';
+      }
+      const answer = await response.json().catch(() => ({}));
+      if (!response.ok) return `Nothing was decided: ${typeof answer?.error === 'string' ? answer.error : `HTTP ${response.status}`}`;
+      return answer.note?.status === 'accepted' ? `Accepted: it enters this room's memory as a new note, held first like any other.` : 'Declined: it stays out of this room\'s memory.';
+    }
     default:
       throw Object.assign(new Error(`Unknown tool: ${name}`), { code: -32602 });
   }

package/src/modules/image-studio.mjs

@@ -4,6 +4,7 @@
 // the CLIs that cannot draw natively. A switch and a model in config.json.
 
 import { defineModule } from './sdk.mjs';
+import { switchIn } from '../module-scope.mjs';
 import { t } from '../i18n.mjs';
 
 const MODELS = ['gemini-2.5-flash-image', 'gemini-3.1-flash-image', 'gemini-3-pro-image'];
@@ -34,12 +35,20 @@ export default defineModule({
       install: { display: ctx.settings.enabled ? 'disable Image Studio' : 'enable Image Studio (config.json)', platforms: ['gemini', 'claude', 'opencode'] },
     };
   },
+  // Before it turns on, in one project or in all: a key to bill the images against.
+  async ready(ctx) {
+    if (await ctx.services.imageKey()) return null;
+    return { status: 412, body: { error: 'No Gemini API key found. Sign in with the Gemini CLI (/auth → API key) or set GEMINI_API_KEY, then enable Image Studio.' } };
+  },
+  // The room's own image tools follow its switch, wherever the switch was moved from.
+  async onToggle(ctx, enabled) { ctx.services.setImageModule({ enabled, model: ctx.settings.model ?? MODELS[0] }); return null; },
   async toggle(ctx, payload) {
     const enabled = !ctx.settings.enabled;
     const key = await ctx.services.imageKey();
     if (enabled && !key) return { status: 412, body: { error: 'No Gemini API key found. Sign in with the Gemini CLI (/auth → API key) or set GEMINI_API_KEY, then enable Image Studio.' } };
     const model = typeof payload?.model === 'string' && payload.model ? payload.model : (ctx.settings.model ?? MODELS[0]);
-    await ctx.updateConfig({ modules: { imageStudio: { enabled, model } } });
+    // A project's switch is that project's (module-scope.mjs); the model is every project's.
+    await ctx.updateConfig({ modules: { imageStudio: { ...switchIn(ctx.config.modules?.imageStudio ?? {}, ctx.roomId ?? null, enabled), model } } });
     ctx.services.setImageModule({ enabled, model });
     await ctx.record('extension.toggled', { id: 'image-studio', name: 'Image Studio', enabled, model });
     return { status: 200, body: { enabled, model, capabilities: ctx.room.capabilities() } };

package/src/modules/intents.mjs

@@ -19,6 +19,7 @@ import { join } from 'node:path';
 import { defineModule } from './sdk.mjs';
 import { t } from '../i18n.mjs';
 import { IntentsDesk } from './intents-desk.mjs';
+import { moduleOnIn } from '../module-scope.mjs';
 
 const desks = new Map();
 // One desk per project room, made the first time anything asks for it.
@@ -40,7 +41,8 @@ export function deskFor(ctx) {
   return desks.get(where.roomDir);
 }
 
-const enabled = (ctx) => ctx.config?.modules?.intents?.enabled !== false;
+// On unless turned off, for every project or for this one (module-scope.mjs).
+const enabled = (ctx) => moduleOnIn(ctx.config?.modules?.intents ?? {}, ctx.roomId ?? null, true);
 const count = (value) => Math.max(0, Math.min(50, Number.parseInt(value, 10) || 0));
 const modeOf = (value) => (Number.isInteger(value) && value >= 0 && value <= 4 ? value : null);
 const nameOrNull = (value) => (typeof value === 'string' && /^[A-Za-z0-9][A-Za-z0-9._:/-]{0,120}$/.test(value) ? value : null);

package/src/modules/local-models.mjs

@@ -0,0 +1,124 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// MADRE · © 2026 Jossue Alcalá · GNU AGPL v3 with additional terms (Section 7): ADDITIONAL-TERMS.md
+// What this computer can do with a local AI, measured and not assumed (2026-10-16).
+//
+// The local AI was sized for one machine: a 16 GB Mac ran a 3B model and trained a 1.5B one, and
+// a 32 GB one trained a 3B. A person with a 128 GB Mac Studio or a 24 GB graphics card can run and
+// train far larger models, and a person with 8 GB should not be offered what will not load. This
+// reads the hardware once — the memory the model would live in and what would compute — and sets
+// it against the minimums of each model size, so the room can say, model by model and feature by
+// feature, what this computer runs, what it trains and what it should leave off.
+//
+// The minimums are deliberately conservative, for the whole computer, not the model alone:
+//   · run    a 4-bit model in Ollama with an 8k window, the system and the browser still open;
+//   · train  a LoRA with mlx-lm (on a 4-bit base from 3B up, QLoRA; at full precision below that).
+// On a Mac the memory is unified and the GPU may use about three quarters of it; on an NVIDIA card
+// what counts is its own memory (VRAM). Without either, a model still runs on the processor —
+// slower — and nothing is trained: a LoRA on a processor takes days.
+
+import { execFile } from 'node:child_process';
+import { arch as osArch, cpus as osCpus, platform as osPlatform, totalmem as osTotalmem } from 'node:os';
+
+const GB = 1024 ** 3;
+
+// One family, every size, so a recommendation is a step up or down a single ladder and a model
+// trained at one size is the same model at another. Qwen2.5 Instruct: multilingual (it answers in
+// the human's language), open weights, an Ollama tag and an MLX 4-bit build at every size.
+export const MODEL_TIERS = [
+  { id: '0.5b', params: 0.5, label: 'Qwen2.5 0.5B', ollama: 'qwen2.5:0.5b', base: 'Qwen/Qwen2.5-0.5B-Instruct', runGb: 4, trainGb: 8 },
+  { id: '1.5b', params: 1.5, label: 'Qwen2.5 1.5B', ollama: 'qwen2.5:1.5b', base: 'Qwen/Qwen2.5-1.5B-Instruct', runGb: 6, trainGb: 12 },
+  { id: '3b', params: 3, label: 'Qwen2.5 3B', ollama: 'qwen2.5:3b', base: 'mlx-community/Qwen2.5-3B-Instruct-4bit', quantized: true, runGb: 8, trainGb: 16 },
+  { id: '7b', params: 7, label: 'Qwen2.5 7B', ollama: 'qwen2.5:7b', base: 'mlx-community/Qwen2.5-7B-Instruct-4bit', quantized: true, runGb: 12, trainGb: 24 },
+  { id: '14b', params: 14, label: 'Qwen2.5 14B', ollama: 'qwen2.5:14b', base: 'mlx-community/Qwen2.5-14B-Instruct-4bit', quantized: true, runGb: 20, trainGb: 36 },
+  { id: '32b', params: 32, label: 'Qwen2.5 32B', ollama: 'qwen2.5:32b', base: 'mlx-community/Qwen2.5-32B-Instruct-4bit', quantized: true, runGb: 36, trainGb: 64 },
+  { id: '72b', params: 72, label: 'Qwen2.5 72B', ollama: 'qwen2.5:72b', base: 'mlx-community/Qwen2.5-72B-Instruct-4bit', quantized: true, runGb: 64, trainGb: 128 },
+];
+
+// What the local AI does in MADRE, and the smallest model each one is worth turning on with. Below
+// it the feature works but answers poorly enough that it is better left off.
+export const LOCAL_FEATURES = [
+  { id: 'search', needs: null },            // search by meaning: an embedding model, ~0.3 GB
+  { id: 'archivist', needs: '3b' },         // the notes it distils from each conversation
+  { id: 'agent', needs: '3b' },             // @madre answering in a project
+  { id: 'coordinator', needs: '7b' },       // the Coordinator answering about every project
+  { id: 'train', needs: '1.5b', train: true }, // training your own model on what the project knows
+];
+
+const run = (file, args, { timeoutMs = 2500, exec = execFile } = {}) => new Promise((resolve) => {
+  try {
+    exec(file, args, { timeout: timeoutMs, windowsHide: true }, (error, stdout) => resolve(error ? null : String(stdout ?? '')));
+  } catch { resolve(null); }
+});
+
+// NVIDIA's own tool, if the card and its driver are there: name and memory of each card, in MiB.
+export function parseNvidia(output) {
+  return String(output ?? '').split('\n').map((line) => line.split(',').map((part) => part.trim())).filter(([name, mib]) => name && Number.isFinite(Number(mib)))
+    .map(([name, mib]) => ({ name, vramGb: Math.round(Number(mib) / 1024) }));
+}
+
+// The hardware, read once. Everything is injectable so the reading can be tested on any machine.
+export async function detectHardware({ platform = osPlatform(), arch = osArch(), totalmem = osTotalmem(), cpus = osCpus(), exec = execFile } = {}) {
+  const memoryGb = Math.round(totalmem / GB);
+  const cores = Array.isArray(cpus) ? cpus.length : 0;
+  let chip = Array.isArray(cpus) && cpus[0]?.model ? String(cpus[0].model).trim() : null;
+  if (platform === 'darwin') {
+    const brand = await run('sysctl', ['-n', 'machdep.cpu.brand_string'], { exec });
+    if (brand?.trim()) chip = brand.trim();
+  }
+  // Apple silicon: one memory for the processor and the GPU, which MLX and Ollama both use.
+  if (platform === 'darwin' && arch === 'arm64') return { platform, arch, chip, cores, memoryGb, accelerator: 'apple', acceleratorGb: memoryGb, gpus: [] };
+  const gpus = parseNvidia(await run('nvidia-smi', ['--query-gpu=name,memory.total', '--format=csv,noheader,nounits'], { exec }));
+  if (gpus.length) {
+    // A model lives on one card unless it is split; the largest card is what one model may count on.
+    const largest = Math.max(...gpus.map((gpu) => gpu.vramGb));
+    return { platform, arch, chip, cores, memoryGb, accelerator: 'nvidia', acceleratorGb: largest, gpus };
+  }
+  return { platform, arch, chip, cores, memoryGb, accelerator: 'cpu', acceleratorGb: 0, gpus: [] };
+}
+
+// The memory a model may count on, in the units the minimums are written in (a whole Mac's).
+// A Mac's GPU takes about three quarters of the unified memory, which the minimums already allow
+// for; an NVIDIA card gives the model all of its own, so its VRAM counts for a third more.
+export function usableGb(hardware) {
+  if (!hardware) return 0;
+  if (hardware.accelerator === 'apple') return hardware.acceleratorGb;
+  if (hardware.accelerator === 'nvidia') return Math.round(hardware.acceleratorGb / 0.75);
+  return hardware.memoryGb;
+}
+
+// Model by model: does it run here (fast, slowly on the processor, or not), does it train here,
+// and why not. Then the one to recommend for each, and what each feature of the local AI may use.
+export function hardwareFit(hardware) {
+  const usable = usableGb(hardware);
+  const accelerated = hardware?.accelerator === 'apple' || hardware?.accelerator === 'nvidia';
+  const models = MODEL_TIERS.map((tier) => {
+    const runs = usable >= tier.runGb ? (accelerated ? 'yes' : 'slow') : 'no';
+    const trains = accelerated && usable >= tier.trainGb ? 'yes' : 'no';
+    const trainWhy = !accelerated ? 'no-accelerator' : trains === 'no' ? 'memory' : null;
+    return { ...tier, run: runs, train: trains, runWhy: runs === 'no' ? 'memory' : runs === 'slow' ? 'no-accelerator' : null, trainWhy };
+  });
+  // Recommended: the largest that runs well, but no larger than 14B for the everyday model of a
+  // project — beyond that answers come slowly enough to hold the room up. On a processor alone,
+  // no larger than 3B. Training: the largest that trains, no larger than what it then runs.
+  const runnable = models.filter((model) => model.run === 'yes');
+  const everyday = (accelerated ? runnable.filter((model) => model.params <= 14) : models.filter((model) => model.run === 'slow' && model.params <= 3));
+  const run = everyday.at(-1) ?? null;
+  const trainable = models.filter((model) => model.train === 'yes' && runnable.includes(model));
+  const train = trainable.at(-1) ?? null;
+  const largestRun = (accelerated ? runnable : models.filter((model) => model.run === 'slow')).at(-1) ?? null;
+  const order = MODEL_TIERS.map((tier) => tier.id);
+  const features = LOCAL_FEATURES.map((feature) => {
+    if (!feature.needs) return { id: feature.id, ok: true, needs: null };
+    const at = order.indexOf(feature.needs);
+    const ok = feature.train ? Boolean(train) && order.indexOf(train.id) >= at : Boolean(largestRun) && order.indexOf(largestRun.id) >= at;
+    return { id: feature.id, ok, needs: feature.needs, slow: !feature.train && ok && !accelerated };
+  });
+  return { hardware, usableGb: usable, accelerated, models, recommended: { run, train, largestRun }, features };
+}
+
+let measured = null;
+// Read once per process: the hardware does not change under a running room.
+export function hardwareOnce(options) {
+  if (!measured) measured = detectHardware(options).then(hardwareFit).catch(() => hardwareFit({ accelerator: 'cpu', acceleratorGb: 0, memoryGb: 0, gpus: [] }));
+  return measured;
+}

package/src/modules/ollama.mjs

@@ -7,6 +7,15 @@ import { defineModule } from './sdk.mjs';
 import { t } from '../i18n.mjs';
 import { findOnPath } from './helpers.mjs';
 import { RECOMMENDED } from '../ollama.mjs';
+import { hardwareOnce } from './local-models.mjs';
+
+// The chat model to pull is the one this computer runs well (local-models.mjs), not one size for
+// every machine; the embedding model is small enough for all of them. With the hardware, the page
+// says which sizes run here and which features of the local AI are worth turning on.
+export async function recommendedHere() {
+  const fit = await hardwareOnce();
+  return { ...RECOMMENDED, chat: fit.recommended.run?.ollama ?? RECOMMENDED.chat, hardware: fit };
+}
 
 // Ollama is not an npm package, so each system has its own way in. Where MADRE can run it, the
 // command is shown on the button before it runs; where it cannot, it hands over the download.
@@ -73,7 +82,7 @@ export default defineModule({
       models: probe.models.map((model) => model.name),
       status: { installed: settings.enabled && project.on && probe.running && roles.length > 0, detail },
       ollama: { ...view, project },
-      recommended: RECOMMENDED,
+      recommended: await recommendedHere(),
       preflight: probe.running ? { ok: true, problems: [] } : { ok: false, problems: ['Ollama is not running: open the Ollama app or run `ollama serve`, then RECHECK.'] },
       install: { display: settings.enabled ? 'disable Ollama' : 'enable Ollama (config.json)', platforms: [] },
     };
@@ -103,8 +112,8 @@ export default defineModule({
     return { status: 200, body: { enabled, ollama: status } };
   },
   routes: [
-    { method: 'GET', path: '/api/ollama', handler: async (ctx) => ({ status: 200, body: { ollama: await ollamaView(await ctx.services.ollama.wire({ probe: false }), ctx.settings), recommended: RECOMMENDED } }) },
-    { method: 'POST', path: '/api/ollama/probe', handler: async (ctx) => ({ status: 200, body: { ollama: await ollamaView(await ctx.services.ollama.wire(), ctx.settings), recommended: RECOMMENDED } }) },
+    { method: 'GET', path: '/api/ollama', handler: async (ctx) => ({ status: 200, body: { ollama: await ollamaView(await ctx.services.ollama.wire({ probe: false }), ctx.settings), recommended: await recommendedHere() } }) },
+    { method: 'POST', path: '/api/ollama/probe', handler: async (ctx) => ({ status: 200, body: { ollama: await ollamaView(await ctx.services.ollama.wire(), ctx.settings), recommended: await recommendedHere() } }) },
     { method: 'POST', path: '/api/ollama/settings', handler: async (ctx, { payload }) => {
       const next = { ...(ctx.config.modules?.ollama ?? {}) };
       for (const key of ['embeddings', 'archivist', 'agent', 'enabled']) if (typeof payload[key] === 'boolean') next[key] = payload[key];