@jossuealcala/madre 0.7.2 → 1.0.1

package/src/config.mjs

@@ -1,4 +1,5 @@
-import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { randomUUID } from 'node:crypto';
+import { copyFile, mkdir, open, readFile, rename, rm, stat, writeFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
 
@@ -18,21 +19,84 @@ export async function loadConfig(root) {
   }
 }
 
+// Every room on this Mac writes this one file. A write is whole — a draft renamed over the file,
+// so nobody ever reads half of one — and a change is read, applied and written under a lock, so
+// two rooms saving at once keep both changes instead of the last one writing over the other
+// (docs/MACROVERSO.md, S-001).
 export async function saveConfig(root, config) {
   const file = configPath(root);
   await mkdir(dirname(file), { recursive: true });
-  await writeFile(file, `${JSON.stringify(config, null, 2)}\n`, { mode: 0o600 });
+  const draft = `${file}.${process.pid}.${randomUUID()}.tmp`;
+  await writeFile(draft, `${JSON.stringify(config, null, 2)}\n`, { mode: 0o600 });
+  await rename(draft, file);
   return file;
 }
 
-export async function updateConfig(root, patch) {
-  const current = await loadConfig(root);
-  const next = { ...current, ...patch };
-  for (const [key, value] of Object.entries(patch)) {
-    if (value && typeof value === 'object' && !Array.isArray(value)) next[key] = { ...(current[key] ?? {}), ...value };
+async function locked(root, work) {
+  const lock = join(dirname(configPath(root)), 'config.lock');
+  await mkdir(dirname(lock), { recursive: true });
+  let held = false;
+  for (let attempt = 0; attempt < 250 && !held; attempt += 1) {
+    try {
+      await (await open(lock, 'wx')).close();
+      held = true;
+    } catch (error) {
+      if (error.code !== 'EEXIST') throw error;
+      // A lock left by a process that died mid-write is stale after a few seconds.
+      const since = await stat(lock).catch(() => null);
+      if (since && Date.now() - since.mtimeMs > 5000) { await rm(lock, { force: true }); continue; }
+      await new Promise((resolve) => setTimeout(resolve, 20));
+    }
+  }
+  if (!held) throw new Error('The settings are being saved by another room; try again.');
+  try {
+    return await work();
+  } finally {
+    await rm(lock, { force: true });
   }
-  await saveConfig(root, next);
-  return next;
+}
+
+// What a change starts from. A file that is there but is not JSON used to be read as empty, and the
+// change written over it kept only itself: every other setting was gone, with nothing said
+// (2026-10-12, review of 1.0). Now a copy of it is kept beside it first, and that is said.
+async function readForChange(root) {
+  const file = configPath(root);
+  let text;
+  try { text = await readFile(file, 'utf8'); } catch (error) { if (error.code === 'ENOENT') return {}; throw error; }
+  try {
+    const parsed = JSON.parse(text);
+    if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) return parsed;
+  } catch { /* kept below */ }
+  const kept = `${file}.damaged-${new Date().toISOString().replace(/[:.]/g, '-')}`;
+  await copyFile(file, kept).catch(() => {});
+  console.error(`MADRE: ${file} could not be read; a copy was kept at ${kept} before saving over it.`);
+  return {};
+}
+
+// A change that reads what is there and decides from it, all under the lock: checked and written
+// in one step, so two changes at once cannot both pass a check that only one of them should
+// (two signatures of the same pair, a revocation and a recall crossing). `change` gets a copy and
+// returns what to save, or nothing to leave the file as it is.
+export async function withConfig(root, change) {
+  return locked(root, async () => {
+    const current = await readForChange(root);
+    const next = await change(structuredClone(current));
+    if (!next || typeof next !== 'object') return current;
+    await saveConfig(root, next);
+    return next;
+  });
+}
+
+export async function updateConfig(root, patch) {
+  return locked(root, async () => {
+    const current = await readForChange(root);
+    const next = { ...current, ...patch };
+    for (const [key, value] of Object.entries(patch)) {
+      if (value && typeof value === 'object' && !Array.isArray(value)) next[key] = { ...(current[key] ?? {}), ...value };
+    }
+    await saveConfig(root, next);
+    return next;
+  });
 }
 
 // Applies file-backed preferences to the process environment without

package/src/conversation-context.mjs

@@ -41,12 +41,15 @@ export function buildConversationContext(events, { excludeMessageId, maxChars =
     for (let i = from; i < messages.length; i += 1) used += messages[i].sender.length + messages[i].role.length + messages[i].text.length + 4;
     return used;
   };
-  let start = 0;
+  // -1 is «no anchor held»: an anchor on the very first message is index 0, and `!start` read it
+  // as none, so the window was cut early and the human's first request was the first to go
+  // (LOG-15 of the 1.0 review).
+  let start = -1;
   if (Number.isInteger(anchor)) {
     const held = messages.findIndex((message) => message.sequence >= anchor);
     if (held >= 0 && weigh(held) <= budget) start = held;
   }
-  if (!start || weigh(start) > budget) {
+  if (start < 0 || weigh(start) > budget) {
     // Let go of a chunk and then hold: back off until the window sits well under its budget, so
     // there is room for many turns of new words before it has to move again.
     start = messages.length;

package/src/credentials.mjs

@@ -38,6 +38,18 @@ export const OPENCODE_PROVIDERS = [
 
 // What the room offers for each agent that cannot be signed in with a click.
 export function keyPlanFor(id) {
+  if (id === 'claude') {
+    return {
+      agent: 'claude',
+      label: 'Anthropic API key',
+      keyUrl: 'https://console.anthropic.com/settings/keys',
+      writesTo: '~/.claude/settings.json',
+      // Said plainly because it is true: this file is the Claude CLI's own, not MADRE's. A key
+      // there is the one every Claude Code on this computer will use, MADRE's turns included.
+      note: 'The key is written where the Claude CLI looks for it, readable only by you. MADRE keeps no copy. It becomes the account Claude Code uses on this computer, here and in your own terminal, until you remove it.',
+      providers: null,
+    };
+  }
   if (id === 'gemini') {
     return {
       agent: 'gemini',
@@ -99,6 +111,33 @@ async function applyGeminiKey(key, { home, probe }) {
   }
 }
 
+// ---- Claude: `env.ANTHROPIC_API_KEY` in its own settings, confirmed by `claude auth status`.
+// The CLI reads that env block before it runs, which is why a key there is a session: its own
+// status answers `api_key` afterwards. Everything else in the file is left as it was.
+async function applyClaudeKey(key, { home, probe }) {
+  const dir = join(home, '.claude');
+  const file = join(dir, 'settings.json');
+  await mkdir(dir, { recursive: true });
+  const before = await readIfThere(file);
+  try {
+    let settings = {};
+    try { settings = JSON.parse(before ?? '{}') ?? {}; } catch { settings = {}; }
+    if (typeof settings !== 'object' || Array.isArray(settings)) settings = {};
+    settings.env = { ...(settings.env ?? {}), ANTHROPIC_API_KEY: key };
+    await writeFile(file, `${JSON.stringify(settings, null, 2)}\n`, { mode: OWNER_ONLY });
+    await chmod(file, OWNER_ONLY).catch(() => {});
+    const state = await probe();
+    if (state?.state !== 'signed-in') {
+      await restore(file, before);
+      return { ok: false, error: `The key was written but Claude still reads as ${state?.state ?? 'unknown'}${state?.detail ? ` (${state.detail})` : ''}. Nothing was changed.` };
+    }
+    return { ok: true, detail: state.detail ?? 'via API key' };
+  } catch (error) {
+    await restore(file, before);
+    return { ok: false, error: `The key could not be written: ${error.message}` };
+  }
+}
+
 // ---- OpenCode: an entry in its auth.json, confirmed by asking `opencode auth list`.
 async function applyOpenCodeKey(key, { home, provider, executable, run }) {
   const known = OPENCODE_PROVIDERS.some((item) => item.id === provider);
@@ -139,7 +178,48 @@ const runOpenCode = async (executable, args) => {
 export async function applyKey({ agent, key, provider = null, home = homedir(), probe, executable = 'opencode', run = runOpenCode }) {
   const checked = normalizeKey(key);
   if (!checked.ok) return checked;
+  if (agent === 'claude') return applyClaudeKey(checked.key, { home, probe });
   if (agent === 'gemini') return applyGeminiKey(checked.key, { home, probe });
   if (agent === 'opencode') return applyOpenCodeKey(checked.key, { home, provider, executable, run });
   return { ok: false, error: `${agent} does not take a key here: it signs in with a click.` };
 }
+
+// ---- OpenCode's providers, as its auth.json says them: who is signed in and how, never the key.
+// `api` is a key (MADRE's or one pasted in a terminal), `oauth` an account signed in from
+// `opencode auth login`. Anything unreadable reads as nobody.
+export async function readOpenCodeProviders({ home = homedir() } = {}) {
+  const raw = await readIfThere(join(home, '.local', 'share', 'opencode', 'auth.json'));
+  let auth = {};
+  try { auth = JSON.parse(raw ?? '{}') ?? {}; } catch { auth = {}; }
+  if (!auth || typeof auth !== 'object' || Array.isArray(auth)) return [];
+  return Object.entries(auth)
+    .filter(([id, entry]) => /^[\w.-]{1,60}$/.test(id) && entry && typeof entry === 'object')
+    .map(([id, entry]) => ({ id, type: entry.type === 'api' || entry.type === 'oauth' ? entry.type : 'other' }));
+}
+
+// Takes a provider's key out of OpenCode's auth.json, the other entries untouched. Only a key
+// (`api`): an account signed in with OpenCode's own login is signed out where it was signed in.
+// OpenCode is the judge again: if it still lists the provider, the file goes back as it was.
+export async function removeOpenCodeKey({ provider, home = homedir(), executable = 'opencode', run = runOpenCode } = {}) {
+  if (typeof provider !== 'string' || !/^[\w.-]{1,60}$/.test(provider)) return { ok: false, error: 'Pick the provider whose key goes.' };
+  const file = join(home, '.local', 'share', 'opencode', 'auth.json');
+  const before = await readIfThere(file);
+  let auth = {};
+  try { auth = JSON.parse(before ?? '{}') ?? {}; } catch { return { ok: false, error: 'OpenCode\'s auth.json could not be read, so nothing was changed.' }; }
+  if (!auth[provider]) return { ok: false, error: `OpenCode has no key for ${provider}.` };
+  if (auth[provider].type !== 'api') return { ok: false, error: `${provider} is signed in with its account, not a key: sign it out with \`opencode auth logout\` in a terminal.` };
+  try {
+    delete auth[provider];
+    await writeFile(file, `${JSON.stringify(auth, null, 2)}\n`, { mode: OWNER_ONLY });
+    await chmod(file, OWNER_ONLY).catch(() => {});
+    const listed = await run(executable, ['auth', 'list']);
+    if (new RegExp(`\\b${provider.replace(/[.-]/g, '\\$&')}\\b`, 'i').test(listed.replace(/auth\.json/gi, ''))) {
+      await restore(file, before);
+      return { ok: false, error: `OpenCode still lists ${provider}, so MADRE put the file back. Remove it with \`opencode auth logout\` in a terminal.` };
+    }
+    return { ok: true };
+  } catch (error) {
+    await restore(file, before);
+    return { ok: false, error: `The key could not be removed: ${error.message}` };
+  }
+}

package/src/dataset.mjs

@@ -48,7 +48,9 @@ export function pairsFromEvents(events, { project = 'project', home, user, priva
     if (event.type !== 'message.created' || event.ghost || !Number.isInteger(event.sequence)) continue;
     const p = event.payload ?? {};
     if (typeof p.text !== 'string' || !p.text.trim()) continue;
-    if (p.role === 'user') { asks.set(p.messageId, { text: p.originalText ?? p.text, mode: p.mode ?? 1, from: 'you' }); continue; }
+    // An order of BISHOP (via 'bishop', docs/MACROVERSO.md D-S10) is a user message the human did
+    // not write: it is not their words, so neither it nor its answer becomes a pair.
+    if (p.role === 'user') { if (p.via !== 'bishop') asks.set(p.messageId, { text: p.originalText ?? p.text, mode: p.mode ?? 1, from: 'you' }); continue; }
     if (p.role !== 'assistant') continue;
     if (p.status === 'delegated') {
       // An orchestrator's step is a question for the agent it names; its closing turn is not.

package/src/directives.mjs

@@ -9,9 +9,9 @@
 //
 // MADRE runs the steps sequentially as regular room turns, each recorded,
 // each subject to handoff, budget and timeout, and each stoppable by the
-// human. A step addressed to the orchestrator itself becomes its closing
-// turn once the others have answered. Delegated agents cannot delegate
-// further (depth is capped at one), so a plan always terminates.
+// human. The orchestrator gets a closing turn after the others have answered.
+// Delegated agents cannot delegate further (depth is capped at one); the
+// orchestrator may start another bounded wave after reviewing their results.
 
 export const DELEGATION_HELP = (self, others, maxSteps) => [
   `You may put other agents to work: ${others.map((id) => `@${id}`).join(', ')}.`,
@@ -21,8 +21,8 @@ export const DELEGATION_HELP = (self, others, maxSteps) => [
   `@${others[0] ?? 'codex'}: <question for that agent>`,
   `@${self}: <what you will do with their answers, optional closing turn for you>`,
   '```',
-  'A step may name the mode it needs, "@codex #2: create the page" or "@claude #3: fix the router"; MADRE caps it at your own mode and at that agent\'s MAX MODE. Without a number a step inherits the plan\'s mode.',
-  `MADRE runs the steps in order (at most ${maxSteps}), shows every answer in the room, then hands you the closing turn if you asked for one.`,
+  'A step may name the mode it needs, "@codex #2: create the page" or "@claude #3: fix the router"; MADRE uses the human permission for this turn as the ceiling. A higher mode pauses for the human to unlock it for that agent, and #4 always does. Without a number a step only reads, or creates files when the plan may create; ask for #3 by name.',
+  `MADRE runs the steps in order (at most ${maxSteps}), shows every answer in the room, then hands you a closing turn to review progress. If work remains within the human permission, you may end that turn with another pulse plan; at most three waves run from one request.`,
   'The plan block must be the very last thing in your reply: nothing after it, not even a closing sentence. Say everything else before it.',
   'Address each agent once. Do not delegate what you can answer yourself.',
 ].join('\n');
@@ -47,7 +47,7 @@ export function parseDirectives(text, { self, available = [], maxSteps = 4 } = {
       const line = raw.trim();
       if (!line || line.startsWith('#')) continue;
       // "@agent: text" or "@agent #2: text": the mode is a request, capped by the plan's ceiling and the agent's MAX MODE.
-      const match = line.match(/^[-*]?\s*@([a-z0-9_-]+)\s*(?:#([0-3]))?\s*[:：]\s*(.+)$/i);
+      const match = line.match(/^[-*]?\s*@([a-z0-9_-]+)\s*(?:#([0-4]))?\s*[:：]\s*(.+)$/i);
       if (!match) { ignored.push({ line, reason: 'not a step (expected "@agent: text" or "@agent #2: text")' }); continue; }
       const agent = match[1].toLowerCase();
       const instruction = match[3].trim();
@@ -66,8 +66,3 @@ export function parseDirectives(text, { self, available = [], maxSteps = 4 } = {
   }
   return { steps, closing, ignored };
 }
-
-// The reply text without the plan block, for readers who only want the prose.
-export function stripDirectives(text) {
-  return String(text ?? '').replace(/```pulse\s*\n[\s\S]*?```/gi, '').trim();
-}