@jossuealcala/madre 0.5.2 → 0.7.0

package/src/room.mjs

@@ -10,6 +10,7 @@ import { UsageSentinel } from './usage-sentinel.mjs';
 import { BLOCK_SOURCES, buildPrompt, promptParts, sparedChars } from './room/prompt.mjs';
 import { turnCost, observedRate } from './room/economy.mjs';
 import { contextFor } from './room/context.mjs';
+import { VERDICTS } from './memory.mjs';
 import { coldNotes, coldReading } from './cold.mjs';
 import { questionsFor } from './asking.mjs';
 import { coverageExam, consistencyExam, matchExam, exchanges, MATCH_SAMPLE, saysFor } from './exam.mjs';
@@ -28,11 +29,13 @@ import { CODE000_STRIKES } from './mother.mjs';
 import { parseDirectives } from './directives.mjs';
 import { isValidModelName } from './models.mjs';
 import { MODES, SCOPES, SCOPE_LABELS, capabilitySummary, normalizeMode, resolveScopes } from './capabilities.mjs';
-import { createLease, diffSnapshots, snapshot } from './lease.mjs';
+import { createLease, diffSnapshots, namedPaths, snapshot } from './lease.mjs';
 import { stat as statFile } from 'node:fs/promises';
 import { basename as baseName, join as joinPath } from 'node:path';
 import { contentTypeFor } from './files.mjs';
 import { isModuleFile, sdkPaths } from './modules/index.mjs';
+import { validateAshReply } from './modules/ash-policy.mjs';
+import { parseChoice, withoutChoice } from './choices.mjs';
 import { imageStudioFor } from './image-studio.mjs';
 import { CAPABILITIES, imageModuleState } from './capabilities.mjs';
 import { resolveReferences } from './files.mjs';
@@ -64,6 +67,34 @@ const CREATION_VERB = /\b(genera(r|d)?|crea(r|d)?|escrib(e|a|ir)|guarda(r)?|prod
 const CREATION_OBJECT = /\b(archivo|fichero|file|pdf|md|markdown|imagen|image|png|jpe?g|svg|documento|document|docx?|csv|json|xlsx?|pptx?|html|script|carpeta|folder|reporte|report|informe|entregable|poster|logo|diagrama|diagram)\b/i;
 export const looksLikeCreation = (text) => CREATION_VERB.test(String(text ?? '')) && CREATION_OBJECT.test(String(text ?? ''));
 
+// Which decisions the project is standing on, out of what the archive holds. A refuted one is
+// kept by the archive — what was once decided is part of the record — and left out here, because
+// a strip that says "decided" cannot carry something the room has since established is false.
+export function settledDecisions(notes = [], { limit = 3 } = {}) {
+  return notes
+    .filter((note) => note && !note.refutedBy)
+    .slice(0, limit)
+    .map((note) => ({ id: note.id, text: note.text, created: note.created, agent: note.agent, fromSequence: note.fromSequence }));
+}
+
+// Open questions the room could put back on the table, newest and most-carried first.
+//
+// `questionsFor` has three wells; this reads only the first. The other two — memories nobody has
+// ever reached for, a kind of note the archive is short of — are about the health of the archive
+// and belong in NOSTROMO beside the map that shows them. What belongs under a composer is the
+// narrower thing: a question this room asked, recorded as open, and never answered.
+//
+// Refuted and dismissed are out. Carried into more turns ranks higher, because a question the
+// room keeps dragging along unanswered is the one most worth asking out loud.
+export function openQuestions(notes = [], { dismissed = [], limit = 3 } = {}) {
+  const skip = new Set(dismissed ?? []);
+  return notes
+    .filter((note) => note && note.kind === 'question' && !note.refutedBy && !skip.has(`open:${note.id}`))
+    .sort((a, b) => (Number(b.recalled ?? 0) - Number(a.recalled ?? 0)) || (b.id - a.id))
+    .slice(0, limit)
+    .map((note) => ({ id: note.id, text: note.text, carried: Number(note.recalled ?? 0) }));
+}
+
 export class Room {
   #store;
   #agents;
@@ -102,6 +133,7 @@ export class Room {
   #maxConcurrentTurns;
   #planMaxAgeMs;
   #ashEnabled = false;
+  #choicesEnabled = false;
 
   constructor({
     store,
@@ -226,7 +258,7 @@ export class Room {
       outDir: lease.relativeDir,
       scratchDir: lease.scratchDir,
       scopes: SCOPES.filter((scope) => enabled[scope]),
-      unavailable: SCOPES.filter((scope) => !scopes[scope].capable).map((scope) => SCOPE_LABELS[scope]),
+      unavailable: SCOPES.filter((scope) => !scopes[scope].capable),
       planId,
     });
     await this.#emit('mode.granted', { requestId, planId, agent: step.agent, mode, step: index + 1, scope: decision.decision, leaseId: lease.leaseId, message: decision.decision === 'plan' ? `#${mode} granted for the rest of the plan; every writable agent creates inside one lease.` : `#${mode} granted to @${step.agent} for step ${index + 1} only.` });
@@ -314,6 +346,12 @@ export class Room {
     } catch { return null; }
   }
 
+  // Counts only, for the MEMORY dashboard. See RoomMemory#activity.
+  memoryActivity({ days = 30 } = {}) {
+    if (!this.#memory) return null;
+    try { return this.#memory.activity({ days }); } catch { return null; }
+  }
+
   /* ---------- MU/TH/UR's channel ---------- */
 
   motherStatus() { return this.#mother ? this.#mother.status() : null; }
@@ -377,6 +415,26 @@ export class Room {
   // opened: a turn in flight is a reason to wait, not something to race.
   working() { return this.#turns.size > 0; }
 
+  // The decisions this project is standing on, newest first.
+  //
+  // Continuity is the point: a conversation opened a week later, or by another agent, starts
+  // knowing what was already settled instead of relitigating it. Read-only, and it costs no
+  // prompt — these never enter a briefing from here, they are shown to the human.
+  //
+  // A refuted decision is left out. The archive keeps it, because what was once decided is part
+  // of the record, but showing it in a strip titled "what we decided" would be the room asserting
+  // something it has since established is false.
+  // The same shape as decisions(): read from the archive, shown to the human, never in a prompt.
+  questions({ limit = 3 } = {}) {
+    if (!this.#memory) return [];
+    return openQuestions(this.#memory.memories({ kind: 'question', limit: limit * 6 }), { dismissed: this.#dismissedAsks(), limit });
+  }
+
+  decisions({ limit = 3 } = {}) {
+    if (!this.#memory) return [];
+    return settledDecisions(this.#memory.memories({ kind: 'decision', limit: limit * 4 }), { limit });
+  }
+
   memoryResearch() {
     if (!this.#memory) return null;
     const memories = this.#memory.memories({ limit: 500 });
@@ -565,11 +623,15 @@ export class Room {
     return result;
   }
 
-  // The human's verdict on a reply: good, bad, or cleared. The dataset listens.
+  // The human's verdict on a reply: good, bad, or cleared. The dataset listens, and so does the
+  // archive: what the room distilled from that reply changes standing, without a word of it being
+  // rewritten. The text of a note is what the archivist heard; where it stands is what you said.
   async rateMessage(messageId, rating) {
     if (typeof messageId !== 'string' || !messageId.trim()) throw new Error('Which reply? Give its messageId.');
-    if (!['good', 'bad', 'none'].includes(rating)) throw new Error('A rating is good, bad or none.');
-    return this.#emit('message.rated', { messageId, rating, by: 'you' });
+    if (!VERDICTS.includes(rating)) throw new Error(`A verdict is one of ${VERDICTS.join(', ')}.`);
+    const event = await this.#emit('message.rated', { messageId, rating, by: 'you' });
+    this.#memory?.judge(messageId, rating);
+    return event;
   }
 
   // Forgetting is recorded in the ledger like anything else the human does to the room.
@@ -649,7 +711,7 @@ export class Room {
       // Each bill teaches the room what its own words cost, so the next turn can say what it is
       // about to spend before it spends it.
       if (cost.charsPerInputToken) this.#rate = this.#rate ? this.#rate * 0.7 + cost.charsPerInputToken * 0.3 : cost.charsPerInputToken;
-      await this.#emit('turn.cost', { agent, mode, responseMessageId, spared: shape.spared, ...cost });
+      await this.#emit('turn.cost', { agent, mode, responseMessageId, ash: Boolean(cost.blocks.ash), spared: shape.spared, ...cost });
     } catch (error) {
       console.error(`MADRE could not weigh a turn: ${error.message}`);
     }
@@ -693,6 +755,15 @@ export class Room {
     return this.#ashEnabled;
   }
 
+  setChoices(enabled) {
+    this.#choicesEnabled = Boolean(enabled);
+    return this.#choicesEnabled;
+  }
+
+  choicesEnabled() {
+    return this.#choicesEnabled;
+  }
+
   ashEnabled() {
     return this.#ashEnabled;
   }
@@ -772,6 +843,10 @@ export class Room {
   async send({ text, target, model = null, attachments = [], create = false, ash = false, mode = undefined }) {
     const parsed = parseMessage(text, target);
     const requestedMode = normalizeMode(mode, create === true ? 2 : 1);
+    // This is the decision the human made when pressing Send. Capture it before modeCheck() —
+    // the first await — so a concurrent module toggle cannot change the turn after that click.
+    const ashRequested = ash === true;
+    const ashActive = ashRequested && this.#ashEnabled;
     const gate = await this.modeCheck({ target, text, mode: requestedMode });
     if (!gate.ok) throw new Error(gate.error);
     create = requestedMode === 2;
@@ -785,7 +860,6 @@ export class Room {
     // What the human wrote, sent as they wrote it. Ash used to rewrite this line before it left
     // the room; it does not any more, so there is no original to keep beside an abbreviation.
     const text2 = parsed.text || `(${files.length} attached file${files.length === 1 ? '' : 's'})`;
-    const ashActive = ash === true && this.#ashEnabled;
     // "!path" tokens point the agent at project files; only existing files count.
     const references = await resolveReferences(this.#projectRoot, text2);
 
@@ -800,7 +874,7 @@ export class Room {
       sender: 'you',
       target: parsed.target,
       text: text2,
-      ash: ashActive ? { active: true } : undefined,
+      ash: ashRequested ? { requested: true, active: ashActive } : undefined,
       status: 'sent',
       model: chosenModel,
       attachments: files.length ? files.map((file) => ({ id: file.id, name: file.name, fileName: file.fileName, size: file.size, contentType: file.contentType })) : undefined,
@@ -818,7 +892,10 @@ export class Room {
     if (create === true || standing) {
       const scopes = this.scopesFor(parsed.target);
       const enabled = SCOPES.filter((scope) => scopes[scope].enabled && scopes[scope].wired);
-      const unavailable = SCOPES.filter((scope) => !scopes[scope].capable).map((scope) => SCOPE_LABELS[scope]);
+      // The ids travel; the labels only build the English sentence below. A label is already a
+      // word, so the client's translator had nothing to look up and left it as it found it.
+      const unavailable = SCOPES.filter((scope) => !scopes[scope].capable);
+      const unavailableSaid = unavailable.map((scope) => SCOPE_LABELS[scope]);
       const disabled = SCOPES.filter((scope) => scopes[scope].capable && !scopes[scope].enabled && scopes[scope].wired).map((scope) => SCOPE_LABELS[scope]);
       if (!enabled.includes('write') || scopes.maxMode < 2) {
         const alternatives = this.#agents.filter((agent) => agent.ready && agent.id !== parsed.target && this.scopesFor(agent.id).maxMode >= 2).map((agent) => `@${agent.id}`);
@@ -829,7 +906,7 @@ export class Room {
           unavailable,
           disabled,
           alternatives,
-          message: `@${parsed.target} will answer read-only: ${scopes.write.capable ? 'file creation is switched off for it (enable it in CONNECTIONS)' : 'its CLI cannot create files'}${unavailable.length ? `; it cannot ${unavailable.join(' or ')}` : ''}.${alternatives.length ? ` For creation ask ${alternatives.join(' or ')}.` : ''}`,
+          message: `@${parsed.target} will answer read-only: ${scopes.write.capable ? 'file creation is switched off for it (enable it in CONNECTIONS)' : 'its CLI cannot create files'}${unavailableSaid.length ? `; it cannot ${unavailableSaid.join(' or ')}` : ''}.${alternatives.length ? ` For creation ask ${alternatives.join(' or ')}.` : ''}`,
         });
       } else {
         lease = await this.#projectLease({ leaseId: randomUUID(), messageId });
@@ -919,6 +996,27 @@ export class Room {
     await this.#emit('room.alert', { code, message, plans: this.activePlans().length, turns: this.#turns.size });
   }
 
+  // Human brake for ONE answer, which is a different thing from the master brake. STOPALL takes
+  // down every plan and every agent in the room and is meant for when things have run away;
+  // this takes down the one turn you are looking at, because an agent that has hung or started
+  // down the wrong road should not cost the whole room to stop. The agent's process dies with the
+  // abort and the turn records its own failure the way any other failure does.
+  async stopTurn(messageId, reason = t('stopped by the human')) {
+    const turn = this.#turns.get(messageId);
+    if (!turn) return false;
+    // Marked before the abort lands, so the failure it causes carries the mark: the turn ends
+    // like any other failure because the process really was killed, and only this says it was
+    // asked for.
+    turn.stoppedByHuman = true;
+    await this.#emit('turn.stopped', { messageId, agent: turn.agent, planId: turn.planId, reason, by: 'you' });
+    turn.controller.abort(reason);
+    // Waited out, the way the master brake waits: aborting only asks, and the turn still has to
+    // kill its process and record how it ended. Returning before that leaves the caller — and
+    // anything tidying up after it — racing a write that has not happened yet.
+    await turn.promise?.catch(() => {});
+    return true;
+  }
+
   // Human brake: stops the remaining steps of a running plan and interrupts
   // the step in flight. Recorded in the log like everything else.
   async stopPlan(planId, reason = 'stopped by the human') {
@@ -1012,7 +1110,7 @@ export class Room {
   // nowhere. Nothing here counts: a memory read for this was not recalled, the window does not
   // move, and no process is started. It is the document MADRE writes in the human's name, which
   // until now existed only for the instant a CLI was reading it.
-  async briefing({ agent: agentId, mode = 1, text = '' } = {}) {
+  async briefing({ agent: agentId, mode = 1, text = '', ash = false } = {}) {
     const agent = this.#agents.find((one) => one.id === agentId && one.detected);
     if (!agent) return null;
     const priorEvents = await this.#store.readAll();
@@ -1047,7 +1145,7 @@ export class Room {
       context: built.context, recall: built.recall, memories: built.memories,
       attachments: [], references: [], lease,
       scopes: { web: scopes.web.enabled && scopes.web.wired, imageGen: scopes.imageGen.enabled && scopes.imageGen.wired },
-      ash: this.ashEnabled(), mode, escalation: null, mcpServers,
+      ash: ash === true && this.ashEnabled(), mode, escalation: null, mcpServers,
     });
     // Each block with what put it here and what would take it away, so "read, never written" can
     // be checked one block at a time instead of believed.
@@ -1158,6 +1256,7 @@ export class Room {
     let lease = null;
     let controlRun = null;
     let createRun = null;
+    let responseMessageId = null;
     if (mode >= 3 && (requester === 'you' || planId) && depth <= 1 && agentScopes.maxMode >= mode && enabled.write) {
       // CONTROL: the project itself is the writable root, and a checkpoint
       // taken now makes every change of this turn reversible. A plan step gets
@@ -1189,7 +1288,7 @@ export class Room {
         outDir: lease.relativeDir,
         scratchDir: lease.scratchDir,
         scopes: ['write'],
-        unavailable: SCOPES.filter((scope) => !agentScopes[scope].capable).map((scope) => SCOPE_LABELS[scope]),
+        unavailable: SCOPES.filter((scope) => !agentScopes[scope].capable),
         planId,
       });
     }
@@ -1228,7 +1327,7 @@ export class Room {
       const invoke = this.#invokers[agent.adapter];
       if (!invoke) throw new Error(`${agent.label} does not have a supported MADRE adapter.`);
       const before = lease && !lease.control && !lease.create ? await snapshot(lease.outDir) : null;
-      const responseMessageId = randomUUID();
+      responseMessageId = randomUUID();
       const notesBefore = this.#memory ? this.#memory.maxMemoryId() : 0;
       const others = this.delegatesFor(agent.id);
       const mayDelegate = allowDelegation && this.#delegation && depth === 0;
@@ -1238,7 +1337,7 @@ export class Room {
         : [];
       // The prompt and the shape it was built from: one is sent, the other is kept until the CLI
       // says what it cost, so the bill can be attributed to the blocks that caused it.
-      const shaped = this.#promptFor({ agent, text, requester, depth, allowDelegation, context, recall, memories, attachments, references, lease, scopes: turnScopes, imageStudio, ash, mode: turnMode, escalation, mcpServers, sharedLeaseHint: sharedLease && !lease ? 'A creation lease is active for this plan, but file creation is not enabled for you: answer without creating files and say so if asked to create one.' : null });
+      const shaped = this.#promptFor({ agent, text, requester, depth, allowDelegation, context, recall, memories, attachments, references, lease, scopes: turnScopes, imageStudio, ash, choices: this.#choicesEnabled, mode: turnMode, escalation, mcpServers, sharedLeaseHint: sharedLease && !lease ? 'A creation lease is active for this plan, but file creation is not enabled for you: answer without creating files and say so if asked to create one.' : null });
       this.#promptShape.set(responseMessageId, { parts: shaped.parts, spared: shaped.spared });
       // What this turn is about to read, said while it is still reading it. The size is exact;
       // only the conversion to tokens is an estimate, and it is made at this room's own rate.
@@ -1281,6 +1380,21 @@ export class Room {
       // CREATE: what appeared stays and is shown; what existed before is put back and said.
       const createChanges = createRun ? await this.#controlDesk.settle(createRun) : null;
       const artifacts = createChanges ? await this.#artifactsFrom(createChanges.files) : lease && !lease.control ? diffSnapshots(before, await snapshot(lease.outDir), { relativeDir: lease.relativeDir }) : [];
+      // A turn that could write, wrote nothing, and answers naming files. That is the shape of a
+      // write refused without a word — a headless CLI cannot stop to ask, so what the policy does
+      // not allow simply fails and the model reports the file as created. The room does not read
+      // the prose for a claim; it takes the paths the reply names and asks the disk. Only what is
+      // named AND absent is said, so an agent talking about files that exist says nothing here.
+      if (lease && !lease.control && artifacts.length === 0) {
+        const roots = [this.#projectRoot, lease.outDir, lease.realOutDir].filter(Boolean);
+        const named = namedPaths(result.text, { roots });
+        const missing = [];
+        for (const path of named.slice(0, 12)) {
+          const full = path.startsWith('/') ? path : joinPath(this.#projectRoot, path);
+          if (!(await statFile(full).then(() => true, () => false))) missing.push(path);
+        }
+        if (missing.length) await this.#emit('create.missing', { messageId: responseMessageId, agent: agent.id, planId, files: missing });
+      }
       // CONTROL: what really changed in the project, forbidden zones reverted on the spot.
       const controlChanges = controlRun ? await this.#controlDesk.settle(controlRun) : null;
       const directives = mayDelegate
@@ -1294,13 +1408,15 @@ export class Room {
       if (depth > 0 && /```pulse/i.test(result.text)) {
         await this.#alert('nested-delegation', `@${agent.id} tried to open a plan from inside a plan. It was ignored; the sequence stays under @${requester}. STOPALL if the room drifts.`, `nested:${agent.id}`);
       }
+      // A question the agent put to the human: it leaves the text and comes back as buttons.
+      const asked = this.#choicesEnabled && turnMode !== 0 ? parseChoice(result.text) : null;
       await this.#emit('message.created', {
         messageId: responseMessageId,
         parentMessageId: messageId,
         role: 'assistant',
         sender: agent.id,
         target: requester,
-        text: result.text,
+        text: asked ? withoutChoice(result.text) : result.text,
         // What the archive handed this turn, so the room can see its own memory working. The
         // whole point of remembering is invisible until the moment it is used.
         recalled: memories?.length
@@ -1317,6 +1433,11 @@ export class Room {
         artifacts: artifacts.length ? artifacts : undefined,
         delegates: directives.steps.length ? directives.steps.map((step) => step.agent) : undefined,
       });
+      if (ash && turnMode !== 0) {
+        const validation = validateAshReply({ request: text, response: result.text });
+        await this.#emit('ash.validated', { messageId, responseMessageId, agent: agent.id, ...validation });
+      }
+      if (asked) await this.#emit('choice.offered', { messageId, responseMessageId, agent: agent.id, question: asked.question, options: asked.options });
       if (guarded.hits) await this.#emit('privacy.redacted', { agent: agent.id, messageId, responseMessageId, hits: guarded.hits, marker: this.#privacy.marker });
       if (artifacts.length) {
         await this.#emit('artifacts.created', { leaseId: lease.leaseId, messageId, responseMessageId, agent: agent.id, outDir: lease.relativeDir, files: artifacts });
@@ -1342,7 +1463,15 @@ export class Room {
       await this.#emit('agent.completed', { messageId, agent: agent.id, handoffId, planId });
       return { responseMessageId, directives };
     } catch (error) {
-      await this.#emit('message.failed', { messageId, target: agent.id, planId, error: this.#privacy ? this.#privacy.redact(failureMessage(error)).text : failureMessage(error) });
+      if (responseMessageId && this.#promptShape.has(responseMessageId)) {
+        const shape = this.#promptShape.get(responseMessageId);
+        this.#promptShape.delete(responseMessageId);
+        if (turnMode !== 0) {
+          const cost = turnCost(shape.parts, null);
+          await this.#emit('turn.cost', { agent: agent.id, mode: turnMode, responseMessageId, ash: Boolean(cost.blocks.ash), failed: true, spared: shape.spared, ...cost });
+        }
+      }
+      await this.#emit('message.failed', { messageId, target: agent.id, planId, error: this.#privacy ? this.#privacy.redact(failureMessage(error)).text : failureMessage(error), ...(this.#turns.get(messageId)?.stoppedByHuman ? { stopped: true } : {}) });
       return null;
     } finally {
       // Release CONTROL whichever way the turn ended; the checkpoint stays for UNDO.
@@ -1421,18 +1550,21 @@ export class Room {
       if (!plan.stopped && directives.closing) {
         plan.step = directives.steps.length + 1;
         const messageId = randomUUID();
+        const closingMode = ceiling >= 3 ? ceiling : lease ? 2 : 1;
         await this.#emit('message.created', {
           messageId,
           role: 'assistant',
           sender: orchestrator,
           target: orchestrator,
           text: directives.closing,
+          ash: ash ? { active: true } : undefined,
+          mode: closingMode,
           status: 'delegated',
           planId,
           step: plan.step,
           totalSteps: plan.step,
         });
-        await this.#dispatch({ messageId, targetId: orchestrator, text: `${directives.closing}\n(The delegated agents have answered above; this is your closing turn.)`, requester: orchestrator, depth: 1, planId, allowDelegation: false, lease, ash });
+        await this.#dispatch({ messageId, targetId: orchestrator, text: `${directives.closing}\n(The delegated agents have answered above; this is your closing turn.)`, requester: orchestrator, depth: 1, planId, allowDelegation: false, lease, ash, mode: closingMode });
       }
     } finally {
       this.#plans.delete(planId);

package/src/sentinel-errors.mjs

@@ -100,8 +100,12 @@ export class ErrorSentinel {
   // A room event goes by: a failure MU/TH/UR cannot classify is worth a report.
   async observe(event) {
     if (event?.type !== 'message.failed') return null;
-    const { target, error } = event.payload ?? {};
+    const { target, error, stopped } = event.payload ?? {};
     if (typeof error !== 'string' || !error.trim()) return null;
+    // A turn the human stopped is not a condition. It ends exactly like a failure because the
+    // process really was killed, but nothing went wrong and there is nothing for anyone to
+    // diagnose — filing it would be reporting the brake as a fault.
+    if (stopped) return null;
     const known = diagnose(error, target ?? null);
     if (known.length) return null;
     return this.record({ kind: 'unknown', agent: target ?? null, error, at: event.timestamp });