@jossuealcala/madre 0.7.2 → 1.0.1

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

@@ -1,6 +1,7 @@
 import { readFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
+import { OPENCODE_PROVIDERS } from './credentials.mjs';
 
 // Which model a CLI should use for one turn. Every CLI accepts --model; the
 // names come from what is installed locally (Codex's model cache, OpenCode's
@@ -32,15 +33,45 @@ export const KNOWN_MODELS = {
 // 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'],
+  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;
 }
@@ -61,6 +92,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;
 }
@@ -78,25 +152,73 @@ export async function discoverModels({ agents = [], config = {}, home = homedir(
     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(() => ''));
-      const toml = await readFile(join(home, '.codex', 'config.toml'), 'utf8').catch(() => '');
-      cliDefault = parseCodexDefaultModel(toml);
-      effortDefault = parseCodexDefaultEffort(toml);
+      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(() => []);
       cliDefault = process.env.PULSE_OPENCODE_MODEL ?? null;
     }
     const custom = Array.isArray(config.models?.[agent.id]) ? config.models[agent.id] : [];
+    // OpenCode speaks to many providers: what `opencode models` lists is already only the ones
+    // signed in plus OpenCode's own. The person may hide a provider from the chooser (AJUSTES ›
+    // Project › OpenCode); its models are then left out, never the room default.
+    let groups;
+    if (agent.id === 'opencode') {
+      const hidden = new Set(openCodeHidden(config));
+      discovered = discovered.filter((name) => !hidden.has(providerOf(name)));
+      groups = groupOpenCode(unique([...custom, ...discovered]));
+    }
     result[agent.id] = {
+      ...(groups ? { groups } : {}),
       models: unique([...custom, ...discovered, ...known.defaults]),
       default: cliDefault,
       note: known.note,
-      efforts: EFFORTS[agent.id] ?? [],
+      efforts,
       effortDefault: isValidEffort(agent.id, effortDefault) ? effortDefault : null,
+      ...(effortsByModel ? { effortsByModel, effortsShared } : {}),
       source: discovered.length ? 'discovered' : 'known',
     };
   }
   return result;
 }
+
+// ---- OpenCode's models by provider: `provider/model`, named as the person knows the provider.
+export const OPENCODE_OWN = 'opencode';
+export const providerOf = (name) => String(name ?? '').split('/')[0];
+export function openCodeHidden(config = {}) {
+  const hidden = config.opencode?.hidden;
+  return Array.isArray(hidden) ? hidden.filter((id) => typeof id === 'string' && /^[\w.-]{1,60}$/.test(id)) : [];
+}
+export function providerLabel(id) {
+  if (id === OPENCODE_OWN) return 'OpenCode';
+  const known = OPENCODE_PROVIDERS.find((one) => one.id === id);
+  if (known) return known.label;
+  return id.split(/[-_.]/).map((part) => (part ? part[0].toUpperCase() + part.slice(1) : part)).join(' ');
+}
+// Groups in a steady order: the providers with a key first, by name; OpenCode's own models last.
+export function groupOpenCode(names = []) {
+  const byProvider = new Map();
+  for (const name of names) {
+    if (!/^[\w.-]+\/[\w.:/-]+$/.test(name)) continue;
+    const id = providerOf(name);
+    if (!byProvider.has(id)) byProvider.set(id, []);
+    byProvider.get(id).push(name);
+  }
+  return [...byProvider.entries()]
+    .sort(([a], [b]) => Number(a === OPENCODE_OWN) - Number(b === OPENCODE_OWN) || providerLabel(a).localeCompare(providerLabel(b)))
+    .map(([id, models]) => ({ id, label: providerLabel(id), own: id === OPENCODE_OWN, models }));
+}

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.',

package/src/modules/bishop-plan.mjs

@@ -0,0 +1,207 @@
+// BISHOP's plans, without the room around them (docs/MACROVERSO.md, fases 4b y 4c): the block a
+// reply ends with, what each of its lines means on this Mac, and the record the buttons act on.
+// Nothing here sends, signs or starts anything; src/modules/bishop.mjs does, after a human press
+// or within the mode the human chose.
+import { randomBytes } from 'node:crypto';
+import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { LINK_KINDS, MAX_ORDER_MODE, receivesOrders } from '../enlaces.mjs';
+import { salasRoomId } from '../salas.mjs';
+
+export const MAX_ORDERS = 4;
+export const MAX_LINKS = 2;
+export const RESULT_CHARS = 1200;
+export const ORDER_CHARS = 2000;
+export const PLAN_FENCE = 'pulse-salas';
+export const BISHOP_MODES = ['manual', 'hybrid', 'auto'];
+const KEEP_PLANS = 40;
+export const clean = (value, max = 60) => String(value ?? '').replace(/[\r\n\t<>]/g, ' ').replace(/\s+/g, ' ').trim().slice(0, max);
+
+/* ---------- the headers a relayed message carries ---------- */
+
+// What a turn reads first when BISHOP's channel brings it a message. English, like everything a
+// turn reads, and with no word of @madre's list of actions (src/adapters/madre.mjs, ACTION_EN):
+// «order» or «delegate» made @madre answer every order with its fixed refusal (S-031).
+// Who sent it is said as it happened: pressed by the human, or on its own within the mode the human
+// chose. Never «sent by the human» for an order nobody pressed.
+export const orderHeader = ({ step, total, plan, auto = false }) => `BISHOP › ${step}/${total} · plan ${plan} · from Salas, ${auto ? 'sent on its own within the mode the human chose' : 'sent by the human'}. Answer in this room only; this turn cannot pass anything on to other rooms.`;
+export const consultHeader = ({ room }) => `BISHOP › question from room ${clean(room, 60)}, asked by the human there. Answer from what you know of the linked rooms; this turn ends with the answer.`;
+export const ORDER_HEADER = /^BISHOP › (\d+)\/(\d+) · plan (p-[0-9a-f]{6})\b/;
+export const CONSULT_HEADER = /^BISHOP › question from room (.+?), asked by the human there\./;
+
+/* ---------- the block ---------- */
+
+// One order: `@<room>/<agent> #<0-4>: what to do`. The room is its name (it may have spaces) or
+// its id; the agent is a crew id. The mode is a single digit and #3/#4 parse, to be refused later.
+const ORDER_LINE = /^\s*[-*]?\s*@(.+?)\/([a-z][a-z0-9_-]*)\s*#(\d)\s*[:：]\s*(.+)$/i;
+// One link: `enlace <room> → <room>: decision, fact; 30 días; órdenes #1`. The arrow says which way
+// notes travel (the first room hands over, the second reads); ↔ is both ways.
+const LINK_LINE = /^\s*[-*]?\s*(?:enlace|link)\s*:?\s+@?(.+?)\s*(↔|<->|→|->)\s*@?(.+?)\s*[:：]\s*(.+)$/i;
+const KIND_WORDS = new Map([
+  ['decision', 'decision'], ['decisions', 'decision'], ['decisión', 'decision'], ['decision', 'decision'], ['decisiones', 'decision'],
+  ['fact', 'fact'], ['facts', 'fact'], ['hecho', 'fact'], ['hechos', 'fact'],
+  ['preference', 'preference'], ['preferences', 'preference'], ['preferencia', 'preference'], ['preferencias', 'preference'],
+  ['question', 'question'], ['questions', 'question'], ['pregunta', 'question'], ['preguntas', 'question'],
+]);
+const isLine = (line) => ORDER_LINE.test(line) || LINK_LINE.test(line);
+
+function linkTerms(rest) {
+  const [first, ...others] = String(rest).split(/[;·|]/).map((part) => part.trim()).filter(Boolean);
+  const words = String(first ?? '').toLowerCase().split(/\s*,\s*|\s+y\s+|\s+and\s+/).map((word) => word.trim()).filter(Boolean);
+  const kinds = [...new Set(words.map((word) => KIND_WORDS.get(word)).filter(Boolean))];
+  const unknown = words.filter((word) => !KIND_WORDS.has(word));
+  let days = null;
+  let orders = null;
+  for (const part of others) {
+    const span = part.match(/(\d{1,3})\s*(?:d|días|dias|day|days)\b/i);
+    if (span) days = Number(span[1]);
+    const ceiling = part.match(/(?:órdenes|ordenes|orders?)\s*(?:hasta|up to)?\s*#?\s*([0-4])/i);
+    if (ceiling) orders = Number(ceiling[1]);
+  }
+  return { kinds, unknown, days, orders };
+}
+
+// The last ```pulse-salas block of a reply, read the way the room reads ```pulse: the reason on the
+// first line, then up to 4 orders and up to 2 links, and nothing after the block. `null` when the
+// reply has no such block; otherwise `{ reason, orders, links, ignored }`, where `ignored` says why
+// each line (or the whole block) was not taken.
+export function parsePlan(text) {
+  const lines = String(text ?? '').replace(/\r\n/g, '\n').split('\n');
+  // Fences as the page reads them (renderMarkdown): a fence opens with an optional language and
+  // only a bare ``` closes it.
+  const blocks = [];
+  let open = null;
+  for (let index = 0; index < lines.length; index += 1) {
+    if (open === null) {
+      const fence = lines[index].match(/^\s*```\s*([\w+-]*)\s*$/);
+      if (fence) open = { start: index, lang: fence[1].toLowerCase() };
+      continue;
+    }
+    if (/^\s*```\s*$/.test(lines[index])) { blocks.push({ ...open, end: index }); open = null; }
+  }
+  const none = (why) => ({ reason: '', orders: [], links: [], ignored: [{ line: '', why }] });
+  if (open?.lang === PLAN_FENCE) return none('the block is not closed');
+  const found = blocks.filter((block) => block.lang === PLAN_FENCE).at(-1);
+  if (!found) return null;
+  if (lines.slice(found.end + 1).join('\n').trim()) return none('text after the block');
+  const body = lines.slice(found.start + 1, found.end).map((line) => line.trim()).filter(Boolean);
+  const reason = body[0] && !isLine(body[0]) ? clean(body.shift(), 300) : '';
+  if (!reason) return none('the first line says why');
+  const orders = [];
+  const links = [];
+  const ignored = [];
+  for (const line of body) {
+    const link = line.match(LINK_LINE);
+    if (link) {
+      if (links.length >= MAX_LINKS) { ignored.push({ line: clean(line, 120), why: 'more than 2 connections' }); continue; }
+      const terms = linkTerms(link[4]);
+      links.push({ from: clean(link[1], 80), to: clean(link[3], 80), both: link[2] === '↔' || link[2] === '<->', ...terms });
+      continue;
+    }
+    const match = line.match(ORDER_LINE);
+    if (!match) { ignored.push({ line: clean(line, 120), why: 'not an order line' }); continue; }
+    const mode = Number(match[3]);
+    if (mode > 4) { ignored.push({ line: clean(line, 120), why: 'no such mode' }); continue; }
+    if (orders.length >= MAX_ORDERS) { ignored.push({ line: clean(line, 120), why: 'more than 4 orders' }); continue; }
+    orders.push({ room: clean(match[1], 80), agent: match[2].toLowerCase(), mode, text: String(match[4]).replace(/[\u0000-\u001f\u007f]/g, ' ').trim().slice(0, ORDER_CHARS) });
+  }
+  return { reason, orders, links, ignored };
+}
+
+/* ---------- what each line means on this Mac ---------- */
+
+// A room by its id, or by a name only one room on this Mac has.
+function findRoom(rooms, wanted) {
+  const byId = rooms.filter((room) => room.id === wanted);
+  if (byId.length) return byId;
+  const lower = String(wanted).toLowerCase();
+  return rooms.filter((room) => String(room.name).toLowerCase() === lower);
+}
+
+// One parsed order, checked: the room, an agent of this crew, a contract in force that lets BISHOP
+// give orders to it and up to which mode. An order that fails a check stays on the card with its
+// reason and no button; #3 and #4 become a proposal for that room.
+export function resolveOrder(order, step, { rooms, contracts, salas, agents }) {
+  const crew = new Set((agents ?? []).filter((agent) => agent.detected).map((agent) => agent.id));
+  const named = findRoom(rooms, order.room);
+  const base = { step, room: named[0]?.id ?? null, name: named[0]?.name ?? order.room, agent: order.agent, mode: order.mode, text: order.text, contract: null, maxMode: null, asked: order.room };
+  if (!named.length) return { ...base, status: 'blocked', why: 'MADRE does not know that project on this Mac.' };
+  if (named.length > 1) return { ...base, room: null, status: 'blocked', why: 'Two projects on this Mac have that name; use the project id.' };
+  if (named[0].id === salas) return { ...base, status: 'blocked', why: 'The Coordinator lives in this project; it gives orders to the others.' };
+  if (!crew.has(order.agent)) return { ...base, status: 'blocked', why: 'No such agent on this Mac.' };
+  const contract = contracts.find((one) => receivesOrders(one, salas) === named[0].id) ?? null;
+  if (!contract) return { ...base, status: 'blocked', why: 'No signed connection lets the Coordinator give orders to that project.' };
+  const maxMode = Math.min(contract.orders.maxMode, MAX_ORDER_MODE);
+  if (order.mode >= 3) return { ...base, contract: contract.id, maxMode, status: 'proposal', why: '#3 and #4 never travel: unlock it yourself in that project.' };
+  if (order.mode > maxMode) return { ...base, contract: contract.id, maxMode, status: 'blocked', why: 'That connection allows orders up to #{n}.', whyArgs: { n: maxMode } };
+  return { ...base, contract: contract.id, maxMode, status: 'ready', why: null };
+}
+export const resolveOrders = ({ orders, ...where }) => orders.map((order, index) => resolveOrder(order, index + 1, where));
+
+// One proposed link, checked the way the sheet of Salas and `normalizeContract` would: two rooms
+// this Mac knows, the room of Salas never handing over, kinds that may cross, orders only with
+// Salas at one end. A pair already connected, either way round, says so. Signing it is the human's press.
+export function resolveLinks({ links, rooms, contracts, salas }) {
+  return links.map((link, index) => {
+    const from = findRoom(rooms, link.from);
+    const to = findRoom(rooms, link.to);
+    const base = { index, from: from[0]?.id ?? null, fromName: from[0]?.name ?? link.from, to: to[0]?.id ?? null, toName: to[0]?.name ?? link.to, direction: link.both ? 'both' : 'a→b', kinds: link.kinds, days: link.days, orders: null, receives: null };
+    if (from.length !== 1 || to.length !== 1) return { ...base, status: 'blocked', why: from.length > 1 || to.length > 1 ? 'Two projects on this Mac have that name; use the project id.' : 'MADRE does not know that project on this Mac.' };
+    if (base.from === base.to) return { ...base, status: 'blocked', why: 'A project cannot be connected to itself.' };
+    if (base.from === salas || (link.both && base.to === salas)) return { ...base, status: 'blocked', why: 'The Coordinator\'s project never hands its notes over.' };
+    if (!link.kinds.length || link.unknown.length) return { ...base, status: 'blocked', why: 'Name what crosses: decision, fact, preference or question.' };
+    if (!link.kinds.every((kind) => LINK_KINDS.includes(kind))) return { ...base, status: 'blocked', why: 'Name what crosses: decision, fact, preference or question.' };
+    let orders = null;
+    if (link.orders !== null) {
+      if (base.from !== salas && base.to !== salas) return { ...base, status: 'blocked', why: 'Orders go only on a connection with the Coordinator\'s project.' };
+      orders = { allowed: true, maxMode: Math.min(link.orders, MAX_ORDER_MODE), perHour: 6 };
+    }
+    const receives = orders ? (base.from === salas ? base.to : base.from) : null;
+    // Two projects are connected once (2026-10-11): any connection in force between them, whichever
+    // way it goes, is the one there is; signing another is refused (src/server.mjs).
+    const same = contracts.find((one) => [one.rooms.a, one.rooms.b].sort().join() === [base.from, base.to].sort().join());
+    if (same) return { ...base, orders, receives, status: 'exists', why: 'That connection is already in force.', contract: same.id };
+    return { ...base, orders, receives, status: 'ready', why: null };
+  });
+}
+
+/* ---------- the plans, kept beside the room of Salas ---------- */
+
+// What the buttons act on is read from here, never from the page: the page names a plan and a step.
+const plansFile = (stateRoot) => join(stateRoot, 'rooms', salasRoomId(stateRoot), 'bishop-plans.json');
+const writes = new Map();
+async function readPlans(stateRoot) {
+  try { const data = JSON.parse(await readFile(plansFile(stateRoot), 'utf8')); return data && typeof data.plans === 'object' ? data : { plans: {} }; } catch { return { plans: {} }; }
+}
+// One change at a time per file, written whole and renamed into place.
+export function changePlans(stateRoot, change) {
+  const file = plansFile(stateRoot);
+  const run = (writes.get(file) ?? Promise.resolve()).then(async () => {
+    const data = await readPlans(stateRoot);
+    const result = await change(data);
+    const kept = Object.values(data.plans).sort((a, b) => String(b.createdAt).localeCompare(String(a.createdAt))).slice(0, KEEP_PLANS);
+    data.plans = Object.fromEntries(kept.map((plan) => [plan.id, plan]));
+    await mkdir(join(file, '..'), { recursive: true });
+    const temp = `${file}.${process.pid}.${randomBytes(3).toString('hex')}.tmp`;
+    await writeFile(temp, `${JSON.stringify(data, null, 2)}\n`, { mode: 0o600 });
+    await rename(temp, file);
+    return result;
+  });
+  writes.set(file, run.catch(() => null));
+  return run;
+}
+export const planById = async (stateRoot, id) => (await readPlans(stateRoot)).plans[id] ?? null;
+export const newPlanId = () => `p-${randomBytes(3).toString('hex')}`;
+
+// A plan closes once, when no order is still waiting for a press or an answer and at least one
+// was answered, failed or skipped. The close is a line; it never opens another plan.
+const OPEN_STATES = new Set(['ready', 'sending', 'sent']);
+export function closing(plan) {
+  if (plan.closed || plan.orders.some((order) => OPEN_STATES.has(order.status))) return null;
+  if (!plan.orders.some((order) => ['done', 'failed', 'skipped'].includes(order.status))) return null;
+  plan.closed = true;
+  const count = (...statuses) => plan.orders.filter((order) => statuses.includes(order.status)).length;
+  return { plan: plan.id, done: count('done'), failed: count('failed'), skipped: count('skipped'), blocked: count('blocked', 'proposal', 'delivered') };
+}
+export const publicOrder = ({ step, room, name, agent, mode, text, contract, maxMode, status, why, whyArgs }) => ({ step, room, name, agent, mode, text, contract, maxMode, status, why, ...(whyArgs ? { whyArgs } : {}) });
+export const publicLink = ({ index, from, fromName, to, toName, direction, kinds, days, orders, receives, status, why, contract }) => ({ index, from, fromName, to, toName, direction, kinds, days, orders, receives, status, why, ...(contract ? { contract } : {}) });