@jossuealcala/madre 0.3.3 → 0.4.0

package/src/room.mjs

@@ -1,13 +1,20 @@
-import { invokeCodex } from './adapters/codex.mjs';
-import { invokeClaude } from './adapters/claude.mjs';
-import { invokeGemini } from './adapters/gemini.mjs';
-import { invokeOpenCode } from './adapters/opencode.mjs';
+import { invokeCodex, buildCodexArgs } from './adapters/codex.mjs';
+import { t } from './i18n.mjs';
+import { invokeClaude, buildClaudeArgs } from './adapters/claude.mjs';
+import { invokeGemini, buildGeminiArgs } from './adapters/gemini.mjs';
+import { invokeOpenCode, buildOpenCodeArgs } from './adapters/opencode.mjs';
 import { parseMessage } from './router.mjs';
 import { randomUUID } from 'node:crypto';
 import { basename } from 'node:path';
 import { UsageSentinel } from './usage-sentinel.mjs';
-import { buildPrompt } from './room/prompt.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 { coldNotes, coldReading } from './cold.mjs';
+import { questionsFor } from './asking.mjs';
+import { coverageExam, consistencyExam, matchExam, exchanges, MATCH_SAMPLE, saysFor } from './exam.mjs';
+import { MADRE_ADAPTER, MADRE_AGENT_ID } from './adapters/madre.mjs';
+import { verdictFor } from './verdict.mjs';
 import { ControlDesk } from './room/control.mjs';
 import { Attachments } from './room/attachments.mjs';
 import { GhostLedger } from './room/ghost.mjs';
@@ -15,6 +22,7 @@ import { Escalation } from './room/escalation.mjs';
 import { Budget, budgetTokens } from './room/budget.mjs';
 import { VectorWorker } from './room/vectors.mjs';
 import { Archivist, distillDefaults } from './room/archivist.mjs';
+import { OLLAMA_ARCHIVIST } from './distiller.mjs';
 import { memoryServerForTurn } from './memory-tools.mjs';
 import { CODE000_STRIKES } from './mother.mjs';
 import { parseDirectives } from './directives.mjs';
@@ -24,10 +32,11 @@ import { createLease, diffSnapshots, 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 { imageStudioFor } from './image-studio.mjs';
 import { CAPABILITIES, imageModuleState } from './capabilities.mjs';
 import { resolveReferences } from './files.mjs';
-import { compressAshCode } from './ashcode.mjs';
+import { redactArgs } from './launch.mjs';
 
 // Adapters can fail with multi-line stderr or stack traces. The room keeps only
 // the first meaningful line, bounded, so the event log and the UI stay readable.
@@ -65,10 +74,15 @@ export class Room {
   #contextMaxChars;
   #memory;                 // RoomMemory: durable recall of everything said outside GHOST
   #recallShare;            // fraction of the context budget recall may take
+  #cascade;                // whether recall also carries what a memory keeps arriving with
+  #examRunning = null;     // the test in flight, if any
+  #examProgress = null;
+  #examStop = false;
   #archivist;              // room/archivist: who distils, when, and the bench
   #vectors;                // room/vectors: embeddings filled in the background
   #escalation;             // room/escalation: plan steps waiting for the human
   #ghost = new GhostLedger();
+  #liveListeners = new Set();
   #memoryServer;           // MCP descriptor handed to every turn so the agent can query the memory itself
   #mother = null;          // MotherChannel: her coded words to the crew
   #shuttingDown = false;
@@ -87,7 +101,7 @@ export class Room {
   #maxPlanSteps;
   #maxConcurrentTurns;
   #planMaxAgeMs;
-  #ashCodeEnabled = false;
+  #ashEnabled = false;
 
   constructor({
     store,
@@ -97,6 +111,7 @@ export class Room {
     contextMaxChars = 16000,
     memory = null,
     recallShare = Number(process.env.PULSE_RECALL_SHARE ?? 0.3),
+    cascade = process.env.PULSE_RECALL_CASCADE !== '0',
     distill = {},
     memoryServer = null,
     mother = null,
@@ -118,6 +133,7 @@ export class Room {
     this.#contextMaxChars = contextMaxChars;
     this.#memory = memory;
     this.#recallShare = Math.min(0.6, Math.max(0, Number.isFinite(recallShare) ? recallShare : 0.3));
+    this.#cascade = cascade !== false;
     this.#memoryServer = memoryServer;
     this.#mother = mother;
     this.#privacy = privacy;
@@ -133,6 +149,8 @@ export class Room {
     this.#controlDesk = new ControlDesk({ projectRoot });
     this.#budget = new Budget({ softBudget: softTokenBudget });
     this.#budget.seed(historicalEvents, this.#sentinel);
+    // What this room has been charged per character, from its own past turns.
+    this.#rate = observedRate(historicalEvents);
     this.#vectors = new VectorWorker({ memory, stopped: () => this.#shuttingDown });
     this.#archivist = new Archivist({
       memory,
@@ -218,6 +236,23 @@ export class Room {
   decideMode(requestId, decision) { return this.#escalation.decide(requestId, decision); }
 
   subscribeGhost(listener) { return this.#ghost.subscribe(listener); }
+
+  // A live meter is not a fact about the room: it says what a turn is reading while it reads it,
+  // and a second later the bill says what it really cost. Writing it to the ledger would spend a
+  // sequence number on something nothing will ever recall, and shift everything said after it.
+  // It goes out to whoever is watching and nowhere else.
+  #say(type, payload) {
+    const event = { id: `live-${randomUUID()}`, sequence: null, live: true, timestamp: new Date().toISOString(), type, payload };
+    for (const listener of this.#liveListeners) listener(event);
+    return event;
+  }
+
+  // Whoever is watching the room right now. Separate from the ghost channel, which carries turns
+  // that happened off the record: these never happened at all, they are only being reported.
+  subscribeLive(listener) {
+    this.#liveListeners.add(listener);
+    return () => this.#liveListeners.delete(listener);
+  }
   async #emit(type, payload) {
     if (this.#ghost.isGhost(type, payload)) return this.#ghost.emit(type, payload);
     const event = await this.#store.append(type, payload);
@@ -234,16 +269,29 @@ export class Room {
   }
   embedNow() { return this.#vectors.runNow(); }
 
-  #contextFor(priorEvents, { messageId, text, omitSynthetic = false }) {
-    return contextFor({ memory: this.#memory, priorEvents, messageId, text, contextMaxChars: this.#contextMaxChars, recallShare: this.#recallShare, remember: (events) => this.#remember(events), omitSynthetic });
+  // Where the transcript an agent reads begins. Held still across turns on purpose: a window
+  // that starts one message later every time is a window a CLI can never match against what it
+  // read last turn, and the transcript is most of what a loaded turn costs.
+  #contextAnchor = null;
+
+  // Characters per input token, as this room's own turns have shown. Null until it has one.
+  #rate = null;
+
+  async #contextFor(priorEvents, { messageId, text, omitSynthetic = false, by = null }) {
+    const built = await contextFor({ memory: this.#memory, priorEvents, messageId, text, contextMaxChars: this.#contextMaxChars, recallShare: this.#recallShare, remember: (events) => this.#remember(events), omitSynthetic, anchor: this.#contextAnchor, by, cascade: this.#cascade });
+    // @madre reads a different transcript to everyone else, so it never sets where the room's
+    // window begins; it only borrows it.
+    if (!omitSynthetic && Number.isInteger(built.context?.anchor)) this.#contextAnchor = built.context.anchor;
+    return built;
   }
 
   // The human tunes the archive from MU/TH/UR; changes apply to the next run.
   distillSettings() {
-    return { ...this.#archivist.settings(), recallShare: this.#recallShare, ollama: Boolean(this.#invokers.ollama) };
+    return { ...this.#archivist.settings(), recallShare: this.#recallShare, cascade: this.#cascade, ollama: Boolean(this.#invokers.ollama) };
   }
   configureDistill(patch = {}) {
     if (Number.isFinite(Number(patch.recallShare))) this.#recallShare = Math.min(0.6, Math.max(0, Number(patch.recallShare)));
+    if (typeof patch.cascade === 'boolean') this.#cascade = patch.cascade;
     this.#archivist.configure(patch);
     return this.distillSettings();
   }
@@ -293,12 +341,197 @@ export class Room {
     return { ...alert, crew };
   }
 
+  // What the room is about to hand this turn, measured rather than guessed. The prompt is
+  // already built when the turn is announced, so its size is known exactly; only the conversion
+  // to tokens is an estimate, and it is made at the rate this room's own turns have shown. Until
+  // the room has been billed once there is no rate, and it says so rather than inventing one.
+  #reading(parts) {
+    const chars = parts.reduce((sum, part) => sum + part.text.length, 0);
+    return { chars, rate: this.#rate ? Number(this.#rate.toFixed(2)) : null, tokens: this.#rate ? Math.round(chars / this.#rate) : null };
+  }
+
+  // Who is free to answer a question that is not a turn: the same pool the archivist draws on,
+  // with the local model in it when there is one. EYECAT reads this to find an impartial judge.
+  bench() {
+    const invokers = this.#invokers;
+    const agents = this.#agents.filter((agent) => agent.adapter !== 'madre-local');
+    return {
+      agents: invokers.ollama ? [OLLAMA_ARCHIVIST, ...agents] : agents,
+      invokers,
+      busy: new Set([...this.#turns.values()].map((turn) => turn.agent).filter(Boolean)),
+      benched: new Set(),
+    };
+  }
+
   /* ---------- NOSTROMO: the human's view of the archive ---------- */
 
   // Every distilled note with the links between those that agree, for the map.
+  // What one memory has to say about its own life: who it keeps arriving with, who asked for it,
+  // and what a refutation did to it or with it. NOSTROMO reads this while a card is open.
+  memoryTraffic(id) {
+    if (!this.#memory) return null;
+    return this.#memory.recallTraffic(id);
+  }
+
+  // Is anything happening in here right now? Asked before a conversation is closed and another
+  // opened: a turn in flight is a reason to wait, not something to race.
+  working() { return this.#turns.size > 0; }
+
   memoryResearch() {
     if (!this.#memory) return null;
-    return { stats: this.memoryStats(), memories: this.#memory.memories({ limit: 500 }), links: this.#memory.memoryLinks() };
+    const memories = this.#memory.memories({ limit: 500 });
+    const links = this.#memory.memoryLinks();
+    // The cold zones: what the archive has never reached for, never linked, and has had plenty
+    // of chances to be. Attached to the notes themselves so the map and the card agree.
+    const cold = coldNotes({ notes: memories, links, batches: this.#memory.recallBatches(), since: this.#memory.recallsSince() });
+    return {
+      stats: this.memoryStats(),
+      memories: memories.map((note) => (cold.has(note.id) ? { ...note, cold: cold.get(note.id) } : note)),
+      links,
+      cold: coldReading(cold, memories),
+      // What the room should ask next, so a thin archive fills where it is thin instead of
+      // deeper where it is already fat. Nothing is sent: the questions are the human's to use.
+      ask: questionsFor({ notes: memories, cold, dismissed: this.#dismissedAsks() }),
+    };
+  }
+
+  /* ---------- the three tests ---------- */
+
+  // What the room can measure about itself, and whether each test can run right now. A test that
+  // cannot run says why instead of returning a number nobody should trust.
+  async exams({ refresh = false, findings = [] } = {}) {
+    let last = {};
+    try { last = JSON.parse(this.#memory?.metaGet('exams') ?? '{}'); } catch { last = {}; }
+    // Said again in the room's language from the numbers that were stored: a reading taken in
+    // another language is still a reading, and its sentence is only how it is said.
+    last = Object.fromEntries(Object.entries(last).map(([id, result]) => [id, { ...result, says: saysFor(result) ?? result.says }]));
+    // The one test that costs nothing is never something to ask for: it is read, not run.
+    if (refresh && this.#memory) last = { ...last, consistency: this.#keepExam(consistencyExam({ findings, notes: this.#memory.memories({ limit: 500 }) })) };
+    const embedder = this.#memory?.embedder?.model ?? null;
+    const localModel = Boolean(this.#invokers[MADRE_ADAPTER]);
+    const cases = this.#memory ? exchanges(await this.#store.readAll()) : [];
+    return {
+      running: this.#examRunning,
+      progress: this.#examProgress,
+      last,
+      can: {
+        coverage: { ok: Boolean(this.#memory) && cases.length > 0, why: !this.#memory ? 'the room has no memory' : cases.length ? null : 'no exchange here is long enough to test with yet', method: embedder ? 'meaning' : 'words' },
+        consistency: { ok: Boolean(this.#memory), why: this.#memory ? null : 'the room has no memory' },
+        match: {
+          ok: Boolean(this.#memory) && localModel && Boolean(embedder) && cases.some((one) => !one.local),
+          why: !localModel ? 'the local model is not running: open MODULES → OLLAMA'
+            : !embedder ? 'this test needs embeddings, which are off'
+              : cases.some((one) => !one.local) ? null : 'nothing here was answered by an agent other than the local one',
+          sample: Math.min(MATCH_SAMPLE, cases.filter((one) => !one.local).length),
+        },
+      },
+      cases: cases.length,
+      embedder,
+    };
+  }
+
+  // Embedding in batches, so a remote embedder is asked a few times and not five hundred.
+  #embedInBatches() {
+    const embedder = this.#memory?.embedder;
+    if (!embedder) return null;
+    return async (texts) => {
+      const out = [];
+      for (let start = 0; start < texts.length; start += 64) out.push(...await embedder.embed(texts.slice(start, start + 64)));
+      return out;
+    };
+  }
+
+  // Running one. Coverage and consistency answer in a moment; the match test asks the local model
+  // a real question at a time and takes minutes, so it runs in the background and reports where
+  // it is. Nothing here writes to the ledger or spends a provider turn.
+  async runExam(which, { findings = [] } = {}) {
+    if (!this.#memory) return { error: 'The room has no memory.' };
+    if (this.#examRunning) return { error: `${this.#examRunning.toUpperCase()} is already running.` };
+    const events = await this.#store.readAll();
+    if (which === 'consistency') {
+      return this.#keepExam(consistencyExam({ findings, notes: this.#memory.memories({ limit: 500 }) }));
+    }
+    if (which === 'coverage') {
+      this.#examRunning = 'coverage';
+      try {
+        const recall = async (text, before) => {
+          const queryVector = await this.#memory.embedQuery(text);
+          const notes = this.#memory.recallMemories(text, { beforeSequence: before, limit: 6, maxChars: 1600, queryVector, fallback: false, track: false, cascade: this.#cascade });
+          const quotes = this.#memory.recall(text, { beforeSequence: before, limit: 6, maxChars: 1600, excerptChars: 420, queryVector });
+          return [...notes.map((note) => note.text), ...(quotes?.entries ?? []).map((entry) => entry.excerpt ?? entry.text)];
+        };
+        return this.#keepExam(await coverageExam({ events, recall, embed: this.#embedInBatches() }));
+      } finally { this.#examRunning = null; }
+    }
+    if (which === 'match') {
+      const invoke = this.#invokers[MADRE_ADAPTER];
+      if (!invoke) return { error: 'The local model is not running. Open MODULES → OLLAMA.' };
+      this.#examRunning = 'match';
+      this.#examProgress = { done: 0, total: 0 };
+      // Answered in the background: the human keeps the room while it runs.
+      void (async () => {
+        try {
+          const result = await matchExam({
+            events,
+            ask: async (question) => (await invoke({ prompt: question, text: question, timeoutMs: 120000 }))?.text ?? '',
+            embed: this.#embedInBatches(),
+            onProgress: (at) => { this.#examProgress = at; },
+            stop: () => this.#examStop,
+          });
+          this.#keepExam(result);
+          // The one test that takes minutes is the one whose answer a person is waiting for, and
+          // until now it landed in a panel they had to go back to. It lands in the room.
+          if (result.ran) {
+            await this.#emit('local.checked', {
+              model: this.#agents.find((agent) => agent.id === MADRE_AGENT_ID)?.version ?? null,
+              passed: Boolean(result.passed), matched: result.matched ?? 0, n: result.n ?? 0, says: result.says,
+            });
+          }
+        } catch (error) {
+          this.#keepExam({ id: 'match', ran: false, at: new Date().toISOString(), says: `The test could not finish: ${error.message}` });
+        } finally { this.#examRunning = null; this.#examStop = false; this.#examProgress = null; }
+      })();
+      return { started: 'match' };
+    }
+    return { error: `No such test "${which}".` };
+  }
+
+  // Coverage costs a few seconds of local arithmetic and nothing else, so it is kept fresh
+  // behind the screen rather than asked for: once a day, only while the embeddings are local
+  // (a remote embedder is the human's money, and money is never spent without being asked), and
+  // never in front of anything. What the panel shows is whatever the last run left.
+  async freshenCoverage({ now = Date.now(), ttlMs = 24 * 60 * 60 * 1000 } = {}) {
+    if (!this.#memory || this.#examRunning) return null;
+    if (!this.#memory.embedder?.local) return null;
+    let last = {};
+    try { last = JSON.parse(this.#memory.metaGet('exams') ?? '{}'); } catch { last = {}; }
+    const at = Date.parse(last.coverage?.at ?? '');
+    if (Number.isFinite(at) && now - at < ttlMs) return null;
+    void this.runExam('coverage').catch(() => null);
+    return { started: 'coverage' };
+  }
+
+  stopExam() { if (this.#examRunning === 'match') this.#examStop = true; return { stopping: this.#examRunning }; }
+
+  #keepExam(result) {
+    let last = {};
+    try { last = JSON.parse(this.#memory?.metaGet('exams') ?? '{}'); } catch { last = {}; }
+    last[result.id] = result;
+    this.#memory?.metaSet('exams', JSON.stringify(last));
+    return result;
+  }
+
+  // Questions the human has waved off. Kept with the archive, because that is what they are about.
+  #dismissedAsks() {
+    try { return JSON.parse(this.#memory?.metaGet('asks_dismissed') ?? '[]'); } catch { return []; }
+  }
+
+  // Waving one off is a small, reversible thing: it stops being offered, and nothing else.
+  dismissAsk(id) {
+    if (!this.#memory || !id) return null;
+    const dismissed = [...new Set([...this.#dismissedAsks(), String(id)])].slice(-200);
+    this.#memory.metaSet('asks_dismissed', JSON.stringify(dismissed));
+    return { dismissed: dismissed.length };
   }
 
   /* ---------- privacy: terms that never travel through the room ---------- */
@@ -402,6 +635,26 @@ export class Room {
 
   budgetWindow() { return this.#budget.view(this.#agents); }
 
+  // What the turn was made of, against what it was charged. A room that cannot see this can only
+  // guess at which part of a prompt is expensive, and a guess in characters is not an answer in
+  // tokens. The words themselves are never written here, only how many of them each block was.
+  async #recordCost(agent, responseMessageId, usage, mode) {
+    const shape = this.#promptShape.get(responseMessageId);
+    this.#promptShape.delete(responseMessageId);
+    if (!shape) return;
+    // A ghost turn is off the record in every sense, this one included.
+    if (mode === 0) return;
+    try {
+      const cost = turnCost(shape.parts, usage);
+      // 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 });
+    } catch (error) {
+      console.error(`MADRE could not weigh a turn: ${error.message}`);
+    }
+  }
+
   async #recordUsage(agent, usage, { messageId = null, responseMessageId = null } = {}) {
     if (!usage) return;
     const charged = this.#budget.record(agent, usage);
@@ -435,13 +688,13 @@ export class Room {
     return this.capabilities();
   }
 
-  setAshCode(enabled) {
-    this.#ashCodeEnabled = Boolean(enabled);
-    return this.#ashCodeEnabled;
+  setAsh(enabled) {
+    this.#ashEnabled = Boolean(enabled);
+    return this.#ashEnabled;
   }
 
-  ashCodeEnabled() {
-    return this.#ashCodeEnabled;
+  ashEnabled() {
+    return this.#ashEnabled;
   }
 
   // A slash command's result, shared with everyone (and with agents through
@@ -516,7 +769,7 @@ export class Room {
     this.#vectors.stop();
   }
 
-  async send({ text, target, model = null, attachments = [], create = false, ashCode = false, mode = undefined }) {
+  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);
     const gate = await this.modeCheck({ target, text, mode: requestedMode });
@@ -529,12 +782,12 @@ export class Room {
     if (!parsed.target) throw new Error('Choose an agent or begin with @agent.');
     if (model !== null && model !== undefined && model !== '' && !isValidModelName(model)) throw new Error('Model name is not valid.');
     const chosenModel = model || null;
-    const originalText = parsed.text || `(${files.length} attached file${files.length === 1 ? '' : 's'})`;
-    const ashActive = ashCode === true && this.#ashCodeEnabled;
-    const abbreviated = ashActive ? compressAshCode(originalText) : null;
-    const text2 = abbreviated?.text ?? originalText;
+    // 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, originalText);
+    const references = await resolveReferences(this.#projectRoot, text2);
 
     // A standing lease (default #2) needs no arming; a ghost never writes.
     const standing = !ghost && !create && Boolean(this.scopesFor(parsed.target).write.always);
@@ -547,8 +800,7 @@ export class Room {
       sender: 'you',
       target: parsed.target,
       text: text2,
-      originalText: abbreviated?.applied ? originalText : undefined,
-      ashCode: ashActive ? { active: true, applied: abbreviated.applied, reason: abbreviated.reason, language: abbreviated.language, originalChars: abbreviated.originalChars, encodedChars: abbreviated.encodedChars } : undefined,
+      ash: ashActive ? { active: true } : 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,
@@ -612,7 +864,7 @@ export class Room {
       allowDelegation = false;
       await this.#alert('plan-active', `A plan by @${[...this.#plans.values()][0].orchestrator} is still running. Your message will be answered, but no second plan will start. Type STOPALL to halt every agent.`, `plan-active:${messageId}`);
     }
-    await this.#track(this.#dispatch({ messageId, targetId: parsed.target, text: text2, requester: 'you', depth: 0, allowDelegation: allowDelegation && !ghost, model: chosenModel, attachments: files, references, lease, ashCode: ashActive, mode: ghost ? 0 : control ? requestedMode : (lease ? 2 : 1) }));
+    await this.#track(this.#dispatch({ messageId, targetId: parsed.target, text: text2, requester: 'you', depth: 0, allowDelegation: allowDelegation && !ghost, model: chosenModel, attachments: files, references, lease, ash: ashActive, mode: ghost ? 0 : control ? requestedMode : (lease ? 2 : 1) }));
   }
 
   // A #2 lease: the project itself is where new files go, and MADRE keeps a scratch folder
@@ -648,7 +900,7 @@ export class Room {
   }
 
   // Master brake: every plan and every in-flight turn, recorded as one event.
-  async stopAll(reason = 'STOPALL by the human') {
+  async stopAll(reason = t('STOPALL by the human')) {
     const plans = this.#plans.size;
     const turns = this.#turns.size;
     for (const plan of this.#plans.values()) plan.stopped = reason;
@@ -682,7 +934,7 @@ export class Room {
 
   // One room turn for one agent. `requester` is who asked ('you' or an
   // orchestrating agent); `depth` 0 turns may delegate, deeper ones may not.
-  async #dispatch({ messageId, targetId, text, requester, depth, planId = null, allowDelegation = true, model = null, attachments = [], references = [], lease = null, ashCode = false, mode = 1, escalation = null }) {
+  async #dispatch({ messageId, targetId, text, requester, depth, planId = null, allowDelegation = true, model = null, attachments = [], references = [], lease = null, ash = false, mode = 1, escalation = null }) {
     if (this.#shuttingDown) return null;
     const agent = this.#agents.find((item) => item.id === targetId);
     if (!agent?.detected) {
@@ -696,7 +948,7 @@ export class Room {
 
     const priorEvents = await this.#store.readAll();
     // @madre never reads its own canned replies back: a small model would echo them.
-    const { context, recall, memories } = await this.#contextFor(priorEvents, { messageId, text, omitSynthetic: Boolean(agent.local) });
+    const { context, recall, memories } = await this.#contextFor(priorEvents, { messageId, text, omitSynthetic: Boolean(agent.local), by: { agent: targetId, turn: messageId } });
     let handoffId = null;
     if (context.previousAgent && context.previousAgent !== targetId) {
       handoffId = randomUUID();
@@ -727,7 +979,7 @@ export class Room {
     await this.#emit('agent.started', { messageId, agent: agent.id, handoffId, planId });
     const controller = new AbortController();
     const turn = { controller, promise: null, planId, agent: agent.id, startedAt: Date.now() };
-    turn.promise = this.#runTurn({ messageId, agent, text, requester, depth, planId, allowDelegation, context, recall, memories, handoffId, signal: controller.signal, model, attachments, references, lease, ashCode, mode, escalation });
+    turn.promise = this.#runTurn({ messageId, agent, text, requester, depth, planId, allowDelegation, context, recall, memories, handoffId, signal: controller.signal, model, attachments, references, lease, ash, mode, escalation });
     this.#turns.set(messageId, turn);
     let outcome = null;
     try {
@@ -739,13 +991,135 @@ export class Room {
     // The orchestrator's turn is over before its plan starts, so it is never
     // counted as in flight while the others work.
     if (outcome?.directives?.steps.length) {
-      await this.#runPlan({ orchestrator: agent.id, parentMessageId: outcome.responseMessageId, directives: outcome.directives, lease, ashCode, mode });
+      await this.#runPlan({ orchestrator: agent.id, parentMessageId: outcome.responseMessageId, directives: outcome.directives, lease, ash, mode });
     }
     return outcome?.responseMessageId ?? null;
   }
 
+  // What the next turn to an agent would carry, built exactly the way a turn builds it and sent
+  // 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 = '' } = {}) {
+    const agent = this.#agents.find((one) => one.id === agentId && one.detected);
+    if (!agent) return null;
+    const priorEvents = await this.#store.readAll();
+    const built = await contextFor({
+      memory: this.#memory, priorEvents, messageId: null, text,
+      contextMaxChars: this.#contextMaxChars, recallShare: this.#recallShare,
+      remember: () => {}, omitSynthetic: Boolean(agent.local), anchor: this.#contextAnchor,
+      cascade: this.#cascade, track: false,
+    });
+    const mcpServers = this.#toolsForTurn && agent.adapter !== 'madre-local'
+      ? await this.#toolsForTurn({ agent: agent.id, mode, lease: null, scratchDir: null }).catch(() => [])
+      : [];
+    const scopes = this.scopesFor(agent.id);
+    // The lease a turn at this mode would be given, shaped exactly as the turn shapes it but
+    // creating nothing: no folder is made, no checkpoint is taken. Without it the preview would
+    // quietly under-report what a #2 or a #3 turn is actually told it may do.
+    const ceiling = Math.min(mode, scopes.maxMode ?? 0);
+    const lease = ceiling >= 2 && scopes.write?.enabled && scopes.write?.wired
+      ? {
+        leaseId: 'would-be-granted-when-you-send',
+        outDir: this.#projectRoot,
+        relativeDir: '.',
+        scratchDir: '.pulse/out/<this turn>',
+        scopes: { ...Object.fromEntries(SCOPES.map((scope) => [scope, scopes[scope].enabled && scopes[scope].wired])), write: true },
+        create: ceiling === 2,
+        control: ceiling >= 3,
+        airlock: ceiling === 4,
+      }
+      : null;
+    const options = this.#promptOptions({
+      agent, text, requester: 'you', depth: 0, allowDelegation: true,
+      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,
+    });
+    // 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.
+    const parts = promptParts(options).map((part) => ({ id: part.id, text: part.text, chars: part.text.length, ...(BLOCK_SOURCES[part.id] ?? { when: null, where: null }) }));
+    return {
+      agent: agent.id, label: agent.label, mode,
+      // What the mode would actually amount to for this agent: its ceiling is its own.
+      ceiling,
+      maxMode: scopes.maxMode ?? 0,
+      lease: Boolean(lease),
+      parts,
+      chars: parts.reduce((sum, part) => sum + part.chars, 0),
+      spared: sparedChars(options),
+      window: { from: built.context?.firstSequence ?? null, through: built.context?.throughSequence ?? null, omitted: built.context?.omittedMessages ?? 0, carried: built.context?.messages?.length ?? 0 },
+      recalled: built.memories?.length ?? 0,
+      quoted: built.recall?.entries?.length ?? 0,
+    };
+  }
+
+  // How this agent's CLI would actually be started: the command line its own adapter builds, the
+  // folder it runs in, the names of what MADRE sets in its environment, and the tool servers
+  // attached for the turn. Built from the same builders the real run uses, and nothing is spawned.
+  //
+  // Values of environment variables are never reported, only names. One of those variables is a
+  // provider key, and a screen that shows what a process is given must not be the easiest place
+  // in the product to read a secret out of.
+  async launch({ agent: agentId, mode = 1 } = {}) {
+    const agent = this.#agents.find((one) => one.id === agentId && one.detected);
+    if (!agent) return null;
+    if (agent.local || agent.adapter === 'madre-local') {
+      return {
+        agent: agent.id, label: agent.label, local: true,
+        says: 'No process is started for @madre: it is the local model answering inside MADRE, through Ollama on this computer.',
+        mcpServers: [], env: [], isolation: [],
+      };
+    }
+    const scopes = this.scopesFor(agent.id);
+    const ceiling = Math.min(mode, scopes.maxMode ?? 0);
+    const mcpServers = this.#toolsForTurn ? await this.#toolsForTurn({ agent: agent.id, mode: ceiling, lease: null, scratchDir: null }).catch(() => []) : [];
+    const prompt = '<the briefing above>';
+    const shared = { projectRoot: this.#projectRoot, prompt, model: null, attachments: [], lease: null, scopes: { web: scopes.web.enabled && scopes.web.wired, imageGen: scopes.imageGen.enabled && scopes.imageGen.wired }, memoryServer: this.#memoryServer, mcpServers };
+    const args = agent.id === 'codex' ? buildCodexArgs(shared)
+      : agent.id === 'claude' ? buildClaudeArgs({ ...shared, attachmentsDir: null, imageStudio: null })
+        : agent.id === 'gemini' ? buildGeminiArgs({ ...shared, policyPath: '<written for this turn, deleted after it>', attachmentsDir: null })
+          : agent.id === 'opencode' ? buildOpenCodeArgs(shared)
+            : null;
+    if (!args) return { agent: agent.id, label: agent.label, local: false, says: `MADRE has no adapter for @${agent.id}.`, mcpServers: [], env: [], isolation: [] };
+    const isolation = {
+      codex: ['--ephemeral: the run keeps no session of its own, so nothing said here reaches another project.'],
+      claude: ['--no-session-persistence: the run keeps no session of its own.', 'Only the project\'s own CLAUDE.md and MADRE\'s briefing are read; hooks, plugins and outside MCP servers are not.'],
+      gemini: ['GEMINI_CLI_HOME points at a temporary home made for this turn and removed after it, so settings, hooks and extensions come from there and not from yours.', 'GEMINI_CLI_NO_RELAUNCH keeps the launcher from spawning a second process MADRE could not stop.'],
+      opencode: ['The run is given the model you chose and nothing else of your session.'],
+    }[agent.id] ?? [];
+    const env = {
+      gemini: [{ name: 'GEMINI_CLI_HOME', note: 'the temporary home for this turn' }, { name: 'GEMINI_CLI_NO_RELAUNCH', note: 'so the launcher stays killable' }],
+    }[agent.id] ?? [];
+    return {
+      agent: agent.id, label: agent.label, local: false,
+      executable: agent.path ?? agent.id,
+      cwd: this.#projectRoot,
+      args: redactArgs(args),
+      promptMarker: prompt,
+      isolation,
+      env,
+      mcpServers: mcpServers.map((server) => ({ name: server.name, command: server.command, args: server.args ?? [], tools: server.tools ?? [], brief: server.brief ?? null, env: Object.keys(server.env ?? {}) })),
+      memoryServer: this.#memoryServer ? { name: this.#memoryServer.name, command: this.#memoryServer.command, args: this.#memoryServer.args ?? [], tools: this.#memoryServer.tools ?? [] } : null,
+    };
+  }
+
+  // What the last prompt for each turn was made of, kept only until its bill arrives.
+  #promptShape = new Map();
+
+  #promptFor(input) {
+    const options = this.#promptOptions(input);
+    const parts = promptParts(options);
+    return { text: parts.map((part) => part.text).join('\n'), parts, spared: sparedChars(options) };
+  }
+
   #prompt(input) {
-    return buildPrompt({
+    return buildPrompt(this.#promptOptions(input));
+  }
+
+  #promptOptions(input) {
+    return ({
       ...input,
       others: this.delegatesFor(input.agent.id),
       delegation: this.#delegation,
@@ -755,11 +1129,12 @@ export class Room {
       memoryServer: this.#memoryServer,
       controlHolder: this.#controlDesk.holder?.agent ?? null,
       privacyMarker: this.#privacy?.marker ?? '[ENTIDAD-ORG]',
+      sdk: sdkPaths(),
       madreModel: this.#agents.find((agent) => agent.id === 'madre' && agent.ready)?.version ?? null,
     });
   }
 
-  async #runTurn({ messageId, agent, text, requester, depth, planId, allowDelegation, context, recall = null, memories = null, handoffId, signal, model = null, attachments = [], references = [], lease: sharedLease = null, ashCode = false, mode = 1, escalation = null }) {
+  async #runTurn({ messageId, agent, text, requester, depth, planId, allowDelegation, context, recall = null, memories = null, handoffId, signal, model = null, attachments = [], references = [], lease: sharedLease = null, ash = false, mode = 1, escalation = null }) {
     // The lease is the human's; what each agent may do inside it is that
     // agent's own enabled scopes. A delegate without file creation runs
     // read-only even while the plan holds a lease.
@@ -846,11 +1221,29 @@ export class Room {
       const mcpServers = this.#toolsForTurn && agent.adapter !== 'madre-local'
         ? await this.#toolsForTurn({ agent: agent.id, mode: turnMode, lease, scratchDir: lease?.scratchDir ? joinPath(this.#projectRoot, lease.scratchDir) : null }).catch(() => [])
         : [];
+      // 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 });
+      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.
+      const reading = this.#reading(shaped.parts);
+      this.#say('turn.reading', { messageId, agent: agent.id, ...reading });
+      // And again as the answer arrives. What is counted is the answer itself, not the protocol
+      // around it, so a CLI that hands over one blob at the end honestly reports nothing until
+      // then rather than a number that means the shape of its own output format.
+      let told = 0;
+      const onProgress = ({ chars }) => {
+        if (!Number.isFinite(chars) || chars <= told) return;
+        told = chars;
+        this.#say('turn.reading', { messageId, agent: agent.id, ...reading, out: chars, outTokens: this.#rate ? Math.round(chars / this.#rate) : null });
+      };
       const result = await invoke({
+        onProgress,
         executable: agent.path,
         projectRoot: this.#projectRoot,
         text,
-        prompt: this.#prompt({ agent, text, requester, depth, allowDelegation, context, recall, memories, attachments, references, lease, scopes: turnScopes, imageStudio, ashCode, 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 }),
+        prompt: shaped.text,
         timeoutMs: this.timeoutFor(agent.id),
         signal,
         model,
@@ -886,16 +1279,19 @@ 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}`);
       }
-      const abbreviated = ashCode ? compressAshCode(result.text) : null;
       await this.#emit('message.created', {
         messageId: responseMessageId,
         parentMessageId: messageId,
         role: 'assistant',
         sender: agent.id,
         target: requester,
-        text: abbreviated?.text ?? result.text,
-        originalText: abbreviated?.applied ? result.text : undefined,
-        ashCode: ashCode ? { active: true, applied: abbreviated.applied, reason: abbreviated.reason, language: abbreviated.language, originalChars: abbreviated.originalChars, encodedChars: abbreviated.encodedChars } : undefined,
+        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
+          ? memories.slice(0, 6).map((note) => ({ id: note.id, kind: note.kind, text: note.text.length > 150 ? `${note.text.slice(0, 149)}…` : note.text, via: note.via ?? 'search' }))
+          : undefined,
+        ash: ash ? { active: true } : undefined,
         status: 'completed',
         planId,
         model,
@@ -909,6 +1305,10 @@ export class Room {
       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 });
+        // A <id>.module.mjs is an agent proposing a module: the human installs it from the room, or not.
+        for (const file of artifacts.filter((item) => isModuleFile(item.path))) {
+          await this.#emit('module.proposed', { agent: agent.id, messageId, responseMessageId, path: file.path, name: file.name });
+        }
       }
       if (createChanges && (createChanges.existingReverted.length || createChanges.forbiddenReverted.length)) {
         await this.#emit('create.reverted', { checkpointId: createChanges.checkpointId, agent: agent.id, messageId, responseMessageId, existing: createChanges.existingReverted, forbidden: createChanges.forbiddenReverted, message: createChanges.message });
@@ -923,6 +1323,7 @@ export class Room {
       }
       if (controlChanges) await this.#emit('control.changed', { ...controlChanges, responseMessageId });
       await this.#recordUsage(agent.id, result.usage, { messageId, responseMessageId });
+      await this.#recordCost(agent.id, responseMessageId, result.usage, turnMode);
       await this.#emit('agent.completed', { messageId, agent: agent.id, handoffId, planId });
       return { responseMessageId, directives };
     } catch (error) {
@@ -935,7 +1336,7 @@ export class Room {
     }
   }
 
-  async #runPlan({ orchestrator, parentMessageId, directives, lease = null, ashCode = false, mode = 1 }) {
+  async #runPlan({ orchestrator, parentMessageId, directives, lease = null, ash = false, mode = 1 }) {
     const planId = randomUUID();
     // The plan's ceiling is the human's mode: #3 when the orchestrator held CONTROL, #2 while a
     // lease exists, #1 otherwise. A step may ask for a mode ("@codex #2: …"); it gets the lowest
@@ -964,8 +1365,7 @@ export class Room {
         if (plan.stopped) break;
         plan.step = index + 1;
         const messageId = randomUUID();
-        const abbreviated = ashCode ? compressAshCode(step.text) : null;
-        const stepText = abbreviated?.text ?? step.text;
+        const stepText = step.text;
         // A creation step in a #1 plan: stop and ask the human before the
         // agent starts, once, with a clock. Permission written by the
         // orchestrator inside the step text never counts.
@@ -993,8 +1393,7 @@ export class Room {
           sender: orchestrator,
           target: step.agent,
           text: stepText,
-          originalText: abbreviated?.applied ? step.text : undefined,
-          ashCode: ashCode ? { active: true, applied: abbreviated.applied, reason: abbreviated.reason, language: abbreviated.language, originalChars: abbreviated.originalChars, encodedChars: abbreviated.encodedChars } : undefined,
+          ash: ash ? { active: true } : undefined,
           status: 'delegated',
           planId,
           mode: wanted >= 3 ? wanted : stepLease && stepScopes.write.enabled ? 2 : 1,
@@ -1002,7 +1401,7 @@ export class Room {
           step: index + 1,
           totalSteps: directives.steps.length + (directives.closing ? 1 : 0),
         });
-        await this.#dispatch({ messageId, targetId: step.agent, text: stepText, requester: orchestrator, depth: 1, planId, allowDelegation: false, lease: wanted >= 3 ? null : stepLease, ashCode, mode: wanted >= 3 ? wanted : stepLease && stepScopes.write.enabled ? 2 : 1, escalation });
+        await this.#dispatch({ messageId, targetId: step.agent, text: stepText, requester: orchestrator, depth: 1, planId, allowDelegation: false, lease: wanted >= 3 ? null : stepLease, ash, mode: wanted >= 3 ? wanted : stepLease && stepScopes.write.enabled ? 2 : 1, escalation });
       }
       if (!plan.stopped && directives.closing) {
         plan.step = directives.steps.length + 1;
@@ -1018,7 +1417,7 @@ export class Room {
           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, ashCode });
+        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 });
       }
     } finally {
       this.#plans.delete(planId);