@jossuealcala/madre 0.7.1 → 1.0.0

package/src/room.mjs

@@ -6,17 +6,18 @@ import { invokeOpenCode, buildOpenCodeArgs } from './adapters/opencode.mjs';
 import { parseMessage } from './router.mjs';
 import { randomUUID } from 'node:crypto';
 import { basename } from 'node:path';
+import { homedir } from 'node:os';
 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 { VERDICTS, travels } 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';
 import { MADRE_ADAPTER, MADRE_AGENT_ID } from './adapters/madre.mjs';
-import { verdictFor } from './verdict.mjs';
 import { ControlDesk } from './room/control.mjs';
+import { RunDesk } from './room/runs.mjs';
 import { Attachments } from './room/attachments.mjs';
 import { GhostLedger } from './room/ghost.mjs';
 import { Escalation } from './room/escalation.mjs';
@@ -27,18 +28,23 @@ import { OLLAMA_ARCHIVIST } from './distiller.mjs';
 import { memoryServerForTurn } from './memory-tools.mjs';
 import { CODE000_STRIKES } from './mother.mjs';
 import { parseDirectives } from './directives.mjs';
-import { isValidModelName } from './models.mjs';
+import { isValidModelName, isValidEffort, belongsElsewhere, MODEL_NOT_FOUND, codexTakes, readCodexEfforts } from './models.mjs';
+import { withListPrice } from './prices.mjs';
 import { MODES, SCOPES, SCOPE_LABELS, capabilitySummary, normalizeMode, resolveScopes } from './capabilities.mjs';
 import { createLease, diffSnapshots, namedPaths, snapshot } from './lease.mjs';
-import { stat as statFile } from 'node:fs/promises';
+import { stat as statFile, readdir, copyFile, readFile as readFileBytes } from 'node:fs/promises';
 import { basename as baseName, join as joinPath } from 'node:path';
-import { contentTypeFor } from './files.mjs';
+import { declaredTypeFor } from './files.mjs';
 import { isModuleFile, sdkPaths } from './modules/index.mjs';
 import { validateAshReply } from './modules/ash-policy.mjs';
+import { PHONE_MAX_MODE } from './bridge/policy.mjs';
 import { parseChoice, withoutChoice } from './choices.mjs';
+import { parseRunRequest, withoutRunRequest, whyText, expandHome } from './runs.mjs';
 import { imageStudioFor } from './image-studio.mjs';
 import { CAPABILITIES, imageModuleState } from './capabilities.mjs';
 import { resolveReferences } from './files.mjs';
+
+const VIA_KINDS = new Set(['iphone', 'ipad', 'android', 'android-tablet', 'other']);
 import { redactArgs } from './launch.mjs';
 
 // Adapters can fail with multi-line stderr or stack traces. The room keeps only
@@ -65,14 +71,19 @@ export { budgetTokens };
 // languages the crew actually speaks here.
 const CREATION_VERB = /\b(genera(r|d)?|crea(r|d)?|escrib(e|a|ir)|guarda(r)?|produce|producir|exporta(r)?|redacta(r)?|construye|create|generate|write|save|export|produce|build|render|draw|make)\b/i;
 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 ?? ''));
+// Unless it says, in so many words, not to write yet: «dame un plan antes de escribir código» was
+// told it had no CREATE lease, for asking for exactly the thing that needs none.
+const NOT_YET = /\b(antes de|sin|todav[ií]a no|a[uú]n no)\s+(escribir|crear|generar|tocar|cambiar|modificar|programar|codificar)\b|\bno\s+(escribas|crees|generes|toques|cambies|modifiques|programes|edites)\b|\b(before|without)\s+(writing|creating|coding|touching|changing|editing)\b|\b(don'?t|do not|not yet)\s+(write|create|code|touch|change|edit)\b/i;
+export const looksLikeCreation = (text) => !NOT_YET.test(String(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)
+    // Only what still travels: a note the human judged bad, or one set aside, is not «decided»
+    // (LOG-10 of the 1.0 review; `travels` is the archive's own rule, verdicts included).
+    .filter((note) => note && !note.refutedBy && travels(note))
     .slice(0, limit)
     .map((note) => ({ id: note.id, text: note.text, created: note.created, agent: note.agent, fromSequence: note.fromSequence }));
 }
@@ -89,12 +100,16 @@ export function settledDecisions(notes = [], { limit = 3 } = {}) {
 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}`))
+    .filter((note) => note && note.kind === 'question' && !note.refutedBy && travels(note) && !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) }));
 }
 
+// A turn's time limit when the human set none: reading answers, writing builds.
+export const READING_TIMEOUT_MS = 180000;
+export const WRITING_TIMEOUT_MS = 600000;
+
 export class Room {
   #store;
   #agents;
@@ -114,6 +129,7 @@ export class Room {
   #escalation;             // room/escalation: plan steps waiting for the human
   #ghost = new GhostLedger();
   #liveListeners = new Set();
+  #quotaSaid = new Map();     // agent + source -> the last reading written to the record
   #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;
@@ -129,11 +145,19 @@ export class Room {
   #delegation;
   #privacy = null;
   #toolsForTurn = null;
+  #bishopForTurn = null;
+  #linkedForTurn = null;
+  // The turns running now, by the id of the answer they will write: which agent, at which mode.
+  // What a tool of a turn says it is (S-021) is checked against this, never taken on its word.
+  #liveTurns = new Map();
   #maxPlanSteps;
   #maxConcurrentTurns;
   #planMaxAgeMs;
   #ashEnabled = false;
   #choicesEnabled = false;
+  #runsEnabled = false;
+  #runDesk = new RunDesk();
+  #runBusy = false;
 
   constructor({
     store,
@@ -149,6 +173,8 @@ export class Room {
     mother = null,
     privacy = null,
     toolsForTurn = null,   // async ({ agent, mode, lease, scratchDir }) => MCP server specs from the modules
+    bishopForTurn = null,  // async ({ agent, mode, text, preview, turn }) => bounded BISHOP context in Salas
+    linkedForTurn = null,  // async ({ agent, mode, text, preview, turn }) => { text, dynamic } notes a link recalls (3e)
     historicalEvents = [],
     invokers = defaultInvokers,
     agentTimeouts = {},
@@ -157,8 +183,17 @@ export class Room {
     maxPlanSteps = 4,
     maxConcurrentTurns = 3,
     planMaxAgeMs = 300000,
+    // The project's one CONTROL desk, when the server keeps several conversations alive at once:
+    // one holder of the working tree across all of them, and an UNDO that works from any.
+    controlDesk = null,
     escalationMs = Number(process.env.PULSE_ESCALATION_MS ?? 180000),
+    // Where Codex keeps its config and its models' cache: the levels each model takes.
+    codexHome = homedir(),
+    // The desk that runs what the human pressed; tests hand in one that sees ports they choose.
+    runDesk = null,
   }) {
+    this.#codexHome = codexHome;
+    if (runDesk) this.#runDesk = runDesk;
     this.#store = store;
     this.#agents = agents;
     this.#projectRoot = projectRoot;
@@ -170,6 +205,8 @@ export class Room {
     this.#mother = mother;
     this.#privacy = privacy;
     this.#toolsForTurn = toolsForTurn;
+    this.#bishopForTurn = bishopForTurn;
+    this.#linkedForTurn = linkedForTurn;
     this.#invokers = invokers;
     this.#agentTimeouts = agentTimeouts;
     this.#maxMessageChars = maxMessageChars;
@@ -178,7 +215,7 @@ export class Room {
     this.#maxConcurrentTurns = maxConcurrentTurns;
     this.#planMaxAgeMs = planMaxAgeMs;
     this.#escalation = new Escalation({ escalationMs });
-    this.#controlDesk = new ControlDesk({ projectRoot });
+    this.#controlDesk = 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.
@@ -223,12 +260,13 @@ export class Room {
   // because the tokens were really spent.
   // CONTROL (#3): one holder per room, every turn between two checkpoints.
   #controlDesk;
+  #codexHome;
   control() { return this.#controlDesk.status(); }
   async undoControl(checkpointId) {
     const result = await this.#controlDesk.undo(checkpointId);
     if (!result.ok) return result;
     const { checkpoint, message, ...rest } = result;
-    await this.#emit('control.reverted', { checkpointId, agent: checkpoint.agent, removed: rest.removed, restored: rest.restored, message });
+    await this.#emit('control.reverted', { checkpointId, agent: checkpoint.agent, command: checkpoint.command ?? undefined, removed: rest.removed, restored: rest.restored, message });
     return { ok: true, ...rest };
   }
 
@@ -249,7 +287,12 @@ export class Room {
     const scopes = this.scopesFor(step.agent);
     const enabled = Object.fromEntries(SCOPES.map((scope) => [scope, scopes[scope].enabled && scopes[scope].wired]));
     const lease = await this.#projectLease({ leaseId: randomUUID(), messageId: parentMessageId });
-    lease.scopes = decision.decision === 'plan' ? Object.fromEntries(SCOPES.map((scope) => [scope, true])) : enabled;
+    // The turn reads its scopes from the ceiling, as every lease does (#runTurn); a lease granted
+    // here had none, so every scope arrived off — no images — while the room had announced them on
+    // (LOG-05 of the 1.0 review). What the human granted is the ceiling; the agent's own switches
+    // still decide below it.
+    lease.scopeCeiling = { write: true, imageGen: true, web: true };
+    lease.scopes = enabled;
     await this.#emit('lease.granted', {
       escalated: decision.decision,
       leaseId: lease.leaseId,
@@ -266,6 +309,9 @@ export class Room {
   }
   // The human's answer to a pending request: 'once', 'plan' or 'deny'.
   decideMode(requestId, decision) { return this.#escalation.decide(requestId, decision); }
+  modeAsked(requestId) { return this.#escalation.modeOf(requestId); }
+  // The modes plans are waiting for the human to grant, as asked.
+  pendingModes() { return this.#escalation.pending(); }
 
   subscribeGhost(listener) { return this.#ghost.subscribe(listener); }
 
@@ -414,6 +460,19 @@ export class Room {
   // 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; }
+  // TURNS asks two things: how many turns this conversation has in flight, and whether it is still
+  // at work at all — a plan between two of its steps has no turn running and is not finished.
+  turnsRunning() { return this.#turns.size; }
+  busy() { return this.#turns.size > 0 || this.#inflight.size > 0 || this.#plans.size > 0; }
+  // A turn running now, by the id of the answer it will write (S-021): its agent and its mode, or
+  // null. What a tool of that turn reports about itself is checked against this.
+  runningTurn(responseMessageId) {
+    const turn = this.#liveTurns.get(String(responseMessageId ?? ''));
+    return turn ? { agent: turn.agent, mode: turn.mode } : null;
+  }
+  // A command the human ran is still alive here (a server, say). Not «working», but a reason to
+  // keep this room open rather than close it under the process.
+  hasLiveRuns() { return this.#runDesk.busy || this.#runDesk.serving().length > 0; }
 
   // The decisions this project is standing on, newest first.
   //
@@ -435,6 +494,16 @@ export class Room {
     return settledDecisions(this.#memory.memories({ kind: 'decision', limit: limit * 4 }), { limit });
   }
 
+  // The notes the archive holds about something on the human's screen — the lines they selected,
+  // the page they pointed at — so a question can be offered from what the room already knows.
+  // Matched by words only: opening a menu sends nothing to an embedding provider. Read without
+  // counting as a recall, because nothing was recalled into a turn.
+  notesAbout(text, { limit = 3 } = {}) {
+    if (!this.#memory || !String(text ?? '').trim()) return [];
+    const notes = this.#memory.recallMemories(String(text).slice(0, 2000), { limit, maxChars: 900, queryVector: null, fallback: false, track: false, cascade: false });
+    return notes.filter((note) => note.kind !== 'aberration').map((note) => ({ id: note.id, kind: note.kind, text: note.text }));
+  }
+
   memoryResearch() {
     if (!this.#memory) return null;
     const memories = this.#memory.memories({ limit: 500 });
@@ -503,7 +572,7 @@ export class Room {
   // 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.#memory) return { error: 'The project has no memory.' };
     if (this.#examRunning) return { error: `${this.#examRunning.toUpperCase()} is already running.` };
     const events = await this.#store.readAll();
     if (which === 'consistency') {
@@ -523,7 +592,7 @@ export class Room {
     }
     if (which === 'match') {
       const invoke = this.#invokers[MADRE_ADAPTER];
-      if (!invoke) return { error: 'The local model is not running. Open MODULES → OLLAMA.' };
+      if (!invoke) return { error: 'The local model is not running. Start Ollama, or open Ollama in Modules.' };
       this.#examRunning = 'match';
       this.#examProgress = { done: 0, total: 0 };
       // Answered in the background: the human keeps the room while it runs.
@@ -653,13 +722,14 @@ export class Room {
     const parsed = parseMessage(text ?? '', target);
     const wanted = normalizeMode(mode, create === true ? 2 : 1);
     if (!parsed.target) return { ok: true, mode: wanted };
-    const scopes = this.scopesFor(parsed.target);
+    const agent = parsed.target;
+    const scopes = this.scopesFor(agent);
     if (wanted >= 3) {
       // #3 CONTROL and #4 AIRLOCK: the ceiling must allow it, and there is one holder at a time.
       // A project without git still checkpoints, in MADRE's shadow repository.
-      if (scopes.maxMode < wanted) return { ok: false, status: 403, mode: wanted, maxMode: scopes.maxMode, error: `@${parsed.target} is capped at #${scopes.maxMode} ${MODES[scopes.maxMode].label}; raise its MAX MODE to #${wanted} in CONNECTIONS to arm ${MODES[wanted].label}.` };
+      if (scopes.maxMode < wanted) return { ok: false, status: 403, mode: wanted, maxMode: scopes.maxMode, error: `@${parsed.target} is capped at #${scopes.maxMode} ${MODES[scopes.maxMode].label}; raise its max mode to #${wanted} in Settings › Permissions to arm ${MODES[wanted].label}.` };
       if (this.#controlDesk.holder) return { ok: false, status: 409, mode: wanted, maxMode: scopes.maxMode, error: `@${this.#controlDesk.holder.agent} already holds ${MODES[this.#controlDesk.holder.mode ?? 3].label} of this project; one holder at a time. STOPALL revokes it.` };
-      return { ok: true, mode: wanted, maxMode: scopes.maxMode };
+      return { ok: true, mode: wanted, maxMode: scopes.maxMode, agent };
     }
     // #2 above the agent's ceiling still goes out: the room answers read-only
     // and says why (lease.refused), the way CREATE has always behaved.
@@ -691,7 +761,17 @@ export class Room {
       observedAt: observedAt ?? undefined,
       official: true,
     };
-    await this.#emit('quota.updated', report);
+    // Written to the record only when it says something new (LOG-12 of the 1.0 review): the poll
+    // asks every minute, and an unchanged reading still became a durable event — some 1,440 a day
+    // per project, each spending a number of the project's count and making every write read a
+    // longer file. An unchanged one goes to whoever is watching, and nowhere else.
+    const said = JSON.stringify([Math.round(report.usedPercent * 10), report.resetAt ?? null, Boolean(report.stale), report.windows ?? null]);
+    const key = `${agent}\n${source}`;
+    if (this.#quotaSaid.get(key) === said) this.#say('quota.updated', report);
+    else {
+      this.#quotaSaid.set(key, said);
+      await this.#emit('quota.updated', report);
+    }
     return this.reportLimit(report);
   }
 
@@ -711,12 +791,23 @@ 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, ash: Boolean(cost.blocks.ash), spared: shape.spared, ...cost });
+      // Which MCP servers rode along: their tool lists go into every call the CLI makes inside the
+      // turn, so the economy can set turns with a server against turns without it.
+      await this.#emit('turn.cost', { agent, mode, responseMessageId, ash: Boolean(cost.blocks.ash), spared: shape.spared, servers: shape.servers ?? [], ...cost });
     } catch (error) {
       console.error(`MADRE could not weigh a turn: ${error.message}`);
     }
   }
 
+  // The model a turn ran on, for its price: the one chosen for it, or the CLI's own default when
+  // MADRE can read it (Codex's config; OpenCode's PULSE_OPENCODE_MODEL). Unknown is null: no price.
+  async #pricedModel(agentId, model) {
+    if (model) return model;
+    if (agentId === 'codex') return (await readCodexEfforts({ home: this.#codexHome }).catch(() => null))?.model ?? null;
+    if (agentId === 'opencode') return process.env.PULSE_OPENCODE_MODEL || null;
+    return null;
+  }
+
   async #recordUsage(agent, usage, { messageId = null, responseMessageId = null } = {}) {
     if (!usage) return;
     const charged = this.#budget.record(agent, usage);
@@ -764,6 +855,71 @@ export class Room {
     return this.#choicesEnabled;
   }
 
+  setRuns(enabled) {
+    this.#runsEnabled = Boolean(enabled);
+    return this.#runsEnabled;
+  }
+
+  runsEnabled() {
+    return this.#runsEnabled;
+  }
+
+  // The human pressed one line of a ```pulse-run an agent wrote. The client names the request and
+  // the line, never the command: what runs is read back from the room's own record of what the
+  // agent asked, so a page cannot run anything that was not shown to the human as a button.
+  async runRequested({ responseMessageId, index }) {
+    if (!this.#runsEnabled) return { ok: false, status: 412, error: 'Command requests are off. Enable them in MODULES.' };
+    const events = await this.#store.readAll();
+    const request = events.find((event) => event.type === 'run.requested' && event.payload.responseMessageId === responseMessageId)?.payload;
+    const command = request?.commands?.[index];
+    if (!command) return { ok: false, status: 404, error: 'That command request is not in this room.' };
+    if (!command.argv) return { ok: false, status: 422, error: `That line does not run: it ${whyText(command)}.` };
+    if (this.#runBusy || this.#runDesk.busy) return { ok: false, status: 409, error: 'A command is already running; wait for it or STOPALL.' };
+    if (this.#controlDesk.holder) return { ok: false, status: 409, error: `@${this.#controlDesk.holder.agent} holds ${MODES[this.#controlDesk.holder.mode ?? 3].label} of this project; run it when the turn ends.` };
+    // Taken before the first await below: two presses in a row must not both get through.
+    this.#runBusy = true;
+    try { return await this.#runCommand({ request, command, responseMessageId, index }); } finally { this.#runBusy = false; }
+  }
+
+  async #runCommand({ request, command, responseMessageId, index }) {
+    const run = { responseMessageId, index, agent: request.agent, line: command.line };
+    await this.#emit('run.started', run);
+    let checkpoint = null;
+    try {
+      checkpoint = await this.#controlDesk.photograph({ id: `${new Date().toISOString().replace(/[-:.TZ]/g, '').slice(0, 14)}-run-${responseMessageId.slice(0, 8)}-${index}`, label: `MADRE run @${request.agent}`, command: command.line });
+    } catch { /* no photograph, no UNDO: the command still runs, and the card says so */ }
+    // The first of two things: the command ends, or it opens a port and becomes a server. A server
+    // answers the press at once and keeps running; its output card comes when it is stopped.
+    let opened = () => {};
+    const serving = new Promise((resolve) => { opened = resolve; });
+    const finished = this.#runDesk.run({ id: `${responseMessageId}:${index}`, argv: expandHome(command), cwd: this.#projectRoot, onServing: (where) => opened(where) })
+      .then(async (result) => {
+        const changes = checkpoint ? await this.#controlDesk.changesSince(checkpoint).catch(() => null) : null;
+        const status = result.stoppedBy ? `stopped (${result.stoppedBy})` : result.exitCode === null ? 'did not start' : `exit ${result.exitCode}`;
+        const event = await this.#emit('command.output', {
+          name: 'run',
+          title: `$ ${command.line} · ${status} · ${(result.durationMs / 1000).toFixed(1)}s · asked by @${request.agent}`,
+          text: `${result.text || '(no output)'}${changes?.files.length ? `\n\nFiles changed: ${changes.files.map((file) => `${file.status} ${file.path}`).join(', ')}` : ''}`,
+          ok: result.ok,
+          args: [],
+          run: { ...run, exitCode: result.exitCode, durationMs: result.durationMs, stoppedBy: result.stoppedBy, served: result.serving ?? undefined, checkpointId: checkpoint?.id, files: changes?.files.length ? changes.files.slice(0, 40) : undefined },
+        });
+        return { ...result, sequence: event.sequence };
+      });
+    const first = await Promise.race([finished.then((ended) => ({ ended })), serving.then((where) => ({ where }))]);
+    if (first.where) {
+      await this.#emit('run.serving', { ...run, ...first.where });
+      finished.catch(() => null);
+      return { ok: true, status: 200, result: { serving: first.where } };
+    }
+    return { ok: true, status: 200, result: { ok: first.ended.ok, exitCode: first.ended.exitCode, sequence: first.ended.sequence } };
+  }
+
+  // The human pressed STOP on one running command's card.
+  stopRun({ responseMessageId, index }) {
+    return this.#runDesk.stop('STOP', `${responseMessageId}:${Number(index)}`);
+  }
+
   ashEnabled() {
     return this.#ashEnabled;
   }
@@ -792,8 +948,11 @@ export class Room {
     };
   }
 
-  timeoutFor(agentId) {
-    return this.#agentTimeouts[agentId] ?? this.#agentTimeouts.default ?? 180000;
+  // How long a turn may run. One that writes gets longer unless the human said otherwise: the first
+  // «write me the app» in an empty project ran past 180 s and was cut with two files of three on
+  // disk. What the human set, for one agent or for all of them, always wins.
+  timeoutFor(agentId, { writing = false } = {}) {
+    return this.#agentTimeouts[agentId] ?? this.#agentTimeouts.default ?? (writing ? WRITING_TIMEOUT_MS : READING_TIMEOUT_MS);
   }
 
   // A process that died mid-turn leaves `agent.started` without a closing
@@ -828,6 +987,8 @@ export class Room {
     this.#archivist.stop();
     this.#vectors.stop();
     this.#shuttingDown = true;
+    // A server a command started does not outlive the room that started it.
+    this.#runDesk.stop('MADRE is shutting down');
     this.#escalation.settleAll(null, 'stopped');
     for (const plan of this.#plans.values()) plan.stopped = 'MADRE is shutting down';
     for (const { controller } of this.#turns.values()) controller.abort('MADRE is shutting down');
@@ -840,13 +1001,36 @@ export class Room {
     this.#vectors.stop();
   }
 
-  async send({ text, target, model = null, attachments = [], create = false, ash = false, mode = undefined }) {
+  async send(options = {}) {
+    await this.#accept(options, null);
+  }
+
+  // An order from BISHOP (docs/MACROVERSO.md, S-028, D-S11). The same door as the human's message
+  // — the mode gate, the lease, the guard and the limits all run as they do for a message — with
+  // three things fixed here and never read from a request: the origin is `bishop`, the turn runs at
+  // depth 1 and it may not delegate, so a room that receives an order cannot open a plan or pass
+  // anything on. Only #0–#2 come in this way; #3 and #4 are armed by the human in this room. The
+  // caller (the BISHOP module, after it checked the contract) gets back the reply or the failure.
+  async order({ text, target, mode = 1 } = {}) {
+    const wanted = Number(mode);
+    if (!Number.isInteger(wanted) || wanted < 0 || wanted > 2) throw new Error('An order comes in at #2 at most; #3 and #4 are armed by the human in this room.');
+    const accepted = await this.#accept({ text, target, mode: wanted }, { via: 'bishop', depth: 1 });
+    const events = await this.#store.readAll();
+    const reply = accepted?.responseMessageId ? events.find((event) => event.type === 'message.created' && event.payload?.messageId === accepted.responseMessageId)?.payload : null;
+    const failed = accepted?.messageId ? events.findLast((event) => event.type === 'message.failed' && event.payload?.messageId === accepted.messageId)?.payload : null;
+    return { messageId: accepted?.messageId ?? null, responseMessageId: accepted?.responseMessageId ?? null, text: reply?.text ?? null, error: reply ? null : failed?.error ?? 'The turn ended without a reply.' };
+  }
+
+  async #accept({ text, target, model = null, effort = null, attachments = [], create = false, ash = false, mode = undefined, draft = false, via = null }, order) {
     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;
+    // A message that came from a phone never goes above #2, whatever reached this far (TEL-01): the
+    // bridge and the route say so first; the room says it last, for any road added later.
+    if (via && requestedMode > PHONE_MAX_MODE) throw new Error('#3 EDIT and #4 FULL ACCESS are opened from the Mac.');
     const gate = await this.modeCheck({ target, text, mode: requestedMode });
     if (!gate.ok) throw new Error(gate.error);
     create = requestedMode === 2;
@@ -856,7 +1040,22 @@ export class Room {
     if (!parsed.text && !files.length) throw new Error('Write a message first.');
     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;
+    // A model chosen for one agent never travels to another. Two ways it used to: a message that
+    // opened with @gemini while the composer pointed at @codex took Codex's model along, and a
+    // name that is plainly another vendor's reached the CLI and came back as an API error that
+    // read like anything but «wrong model». Either way the agent answers on its own default.
+    const redirected = Boolean(target) && parsed.target !== target;
+    const modelIgnored = model && (redirected || belongsElsewhere(parsed.target, model)) ? model : null;
+    const chosenModel = modelIgnored ? null : (model || null);
+    // An effort the target's CLI does not take is dropped, not refused: the composer remembers it
+    // per agent, so a stale one should cost the human nothing but the flag. Codex's levels are the
+    // model's, so a level its model does not take is dropped the same way, and the room says so.
+    let chosenEffort = !redirected && isValidEffort(parsed.target, effort) ? effort : null;
+    let effortIgnored = null;
+    if (chosenEffort && parsed.target === 'codex' && !(await codexTakes(chosenModel, chosenEffort, { home: this.#codexHome }))) {
+      effortIgnored = chosenEffort;
+      chosenEffort = null;
+    }
     // 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'})`;
@@ -872,11 +1071,17 @@ export class Room {
       mode: ghost ? 0 : control ? requestedMode : (standing || create ? 2 : 1),
       role: 'user',
       sender: 'you',
+      // Written from a paired phone: which kind, said by the bridge (docs/MOBILE.md, MOV-008). An
+      // order says `bishop`, set by `order()` in this process and never taken from a request.
+      via: order ? order.via : VIA_KINDS.has(via) ? via : undefined,
       target: parsed.target,
       text: text2,
       ash: ashRequested ? { requested: true, active: ashActive } : undefined,
       status: 'sent',
       model: chosenModel,
+      modelIgnored: modelIgnored ?? undefined,
+      effort: chosenEffort ?? undefined,
+      effortIgnored: effortIgnored ?? undefined,
       attachments: files.length ? files.map((file) => ({ id: file.id, name: file.name, fileName: file.fileName, size: file.size, contentType: file.contentType })) : undefined,
       references: references.length ? references.map(({ excerpt, ...reference }) => reference) : undefined,
       create: create === true ? true : undefined,
@@ -902,20 +1107,25 @@ export class Room {
         await this.#emit('lease.refused', {
           messageId,
           agent: parsed.target,
-          reason: !scopes.write.capable ? `@${parsed.target} cannot create files from its CLI` : scopes.maxMode < 2 ? `@${parsed.target} is capped at #${scopes.maxMode} ${MODES[scopes.maxMode].label} in CONNECTIONS` : `file creation is switched off for @${parsed.target}`,
+          reason: !scopes.write.capable ? `@${parsed.target} cannot create files from its CLI` : scopes.maxMode < 2 ? `@${parsed.target} is capped at #${scopes.maxMode} ${MODES[scopes.maxMode].label} in Settings › Permissions` : `file creation is switched off for @${parsed.target}`,
           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'}${unavailableSaid.length ? `; it cannot ${unavailableSaid.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 (turn it on in Settings › Agents)' : '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 });
+        // `/module` asks for less than #2: one file in its own draft folder. Only a #2 message can
+        // narrow itself this way; a default-#2 lease stays what it is.
+        lease = draft === true && create === true
+          ? await this.#draftLease({ leaseId: randomUUID(), messageId })
+          : await this.#projectLease({ leaseId: randomUUID(), messageId });
         // CREATE authorizes the plan to use each delegate's enabled creation
         // scopes; a default-#2 lease authorizes files only.
         lease.scopeCeiling = { write: true, imageGen: !standing, web: true };
         lease.scopes = Object.fromEntries(SCOPES.map((scope) => [scope, enabled.includes(scope) && (!standing || scope === 'write')]));
         await this.#emit('lease.granted', {
           standing: standing || undefined,
+          draft: lease.draft || undefined,
           leaseId: lease.leaseId,
           messageId,
           agent: parsed.target,
@@ -934,14 +1144,16 @@ export class Room {
         target: parsed.target,
         error: `Message is too long (${parsed.text.length} characters); the limit is ${this.#maxMessageChars}.`,
       });
-      return;
+      return { messageId, responseMessageId: null };
     }
-    let allowDelegation = true;
-    if (this.#plans.size > 0) {
+    // An order never delegates, so a plan already running here has nothing to warn about.
+    let allowDelegation = !order;
+    if (!order && this.#plans.size > 0) {
       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, ash: ashActive, mode: ghost ? 0 : control ? requestedMode : (lease ? 2 : 1) }));
+    const responseMessageId = await this.#track(this.#dispatch({ messageId, targetId: parsed.target, text: text2, requester: 'you', depth: order ? order.depth : 0, allowDelegation: allowDelegation && !ghost, model: chosenModel, effort: chosenEffort, attachments: files, references, lease, ash: ashActive, mode: ghost ? 0 : control ? requestedMode : (lease ? 2 : 1) }));
+    return { messageId, responseMessageId };
   }
 
   // A #2 lease: the project itself is where new files go, and MADRE keeps a scratch folder
@@ -952,13 +1164,66 @@ export class Room {
     return { leaseId, messageId, outDir: this.#projectRoot, relativeDir: '.', scratchDir: scratch.relativeDir, create: true };
   }
 
+  // A lease for one folder of its own and nothing else: `/module` writes one file for the human to
+  // read before installing it, and needs no more than that. Every CLI is told the folder and held
+  // to it; nothing in the project can be touched, so there is no checkpoint to take and no other
+  // turn to wait for.
+  async #draftLease({ leaseId, messageId }) {
+    const draft = await createLease({ projectRoot: this.#projectRoot, leaseId });
+    return { ...draft, messageId, draft: true };
+  }
+
   // Artifacts from a #2 turn: the files the checkpoint saw appear, as the room shows them.
+  // Said once, when a writing turn has to wait for the one already writing in the project.
+  async #sayWaitingToWrite({ messageId, agent }) {
+    const ahead = this.#controlDesk.writer();
+    if (ahead) await this.#emit('write.waiting', { messageId, agent: agent.id, behind: ahead.agent ?? null });
+  }
+
+  // A round's answers, for the local model's closing turn: who was asked, what each one said and
+  // under which number, or that it did not answer. Handed the transcript instead, a 7B model gave
+  // one agent's point to another, left one out and quoted itself.
+  async #roundAnswers(planId) {
+    const events = (await this.#store.readAll()).filter((event) => event.payload?.planId === planId);
+    const asked = [...new Set(events.filter((event) => event.type === 'message.created' && event.payload.status === 'delegated' && event.payload.target !== event.payload.sender).map((event) => event.payload.target))];
+    const answers = asked.map((agent) => {
+      const said = events.find((event) => event.type === 'message.created' && event.payload.role === 'assistant' && event.payload.sender === agent && event.payload.status !== 'delegated');
+      if (said) return { agent, sequence: said.sequence, text: said.payload.text ?? '' };
+      const failed = events.find((event) => event.type === 'message.failed' && event.payload.target === agent);
+      return { agent, failed: true, error: failed ? String(failed.payload.error ?? '').slice(0, 160) : null };
+    });
+    return { asked, answers };
+  }
+
+  // The bytes of files the turn created, for telling a copy from a new file. Images only, and only
+  // a few: this compares what an image tool made, not the project.
+  async #bytesOf(paths) {
+    const images = paths.filter((path) => /\.(png|jpe?g|webp|gif)$/i.test(path)).slice(0, 16);
+    return (await Promise.all(images.map((path) => readFileBytes(joinPath(this.#projectRoot, path)).catch(() => null)))).filter(Boolean);
+  }
+
+  async #draftedIn(scratchDir, { depth = 2 } = {}) {
+    const found = [];
+    const walk = async (relative, level) => {
+      const entries = await readdir(joinPath(this.#projectRoot, relative), { withFileTypes: true }).catch(() => []);
+      for (const entry of entries) {
+        const path = `${relative}/${entry.name}`;
+        if (entry.isDirectory()) { if (level < depth) await walk(path, level + 1); continue; }
+        if (!entry.isFile()) continue;
+        const info = await statFile(joinPath(this.#projectRoot, path)).catch(() => null);
+        found.push({ name: baseName(path), path, size: info?.size ?? 0, contentType: declaredTypeFor(path), status: 'created' });
+      }
+    };
+    await walk(String(scratchDir).replace(/\/$/, ''), 0);
+    return found.sort((a, b) => a.path.localeCompare(b.path));
+  }
+
   async #artifactsFrom(files) {
     const out = [];
     for (const file of files) {
       if (file.status !== 'A') continue;
       const info = await statFile(joinPath(this.#projectRoot, file.path)).catch(() => null);
-      out.push({ name: baseName(file.path), path: file.path, size: info?.size ?? 0, contentType: contentTypeFor(file.path), status: 'created' });
+      out.push({ name: baseName(file.path), path: file.path, size: info?.size ?? 0, contentType: declaredTypeFor(file.path), status: 'created' });
     }
     return out.sort((a, b) => a.path.localeCompare(b.path));
   }
@@ -983,6 +1248,7 @@ export class Room {
     for (const plan of this.#plans.values()) plan.stopped = reason;
     this.#escalation.settleAll(null, 'stopped');
     for (const turn of this.#turns.values()) turn.controller.abort(reason);
+    this.#runDesk.stop('STOPALL');
     await this.#emit('room.stopped', { reason, plans, turns, agents: [...new Set([...this.#turns.values()].map((turn) => turn.agent))] });
     await Promise.allSettled([...this.#turns.values()].map((turn) => turn.promise));
     return { plans, turns };
@@ -1032,11 +1298,16 @@ 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, ash = false, mode = 1, escalation = null }) {
+  async #dispatch({ messageId, targetId, text, requester, depth, planId = null, allowDelegation = true, model = null, effort = 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) {
-      await this.#emit('message.failed', { messageId, target: targetId, planId, error: `${targetId} is not installed on this computer.` });
+      // @madre is not a CLI to install: it is the room's local agent, here while Ollama runs with a
+      // chat model. Saying "not installed" sent people to install something that does not exist.
+      const error = agent?.local || targetId === 'madre'
+        ? `@${targetId} left the room: Ollama is not running. Start Ollama, or open Ollama in Modules.`
+        : `${targetId} is not installed on this computer.`;
+      await this.#emit('message.failed', { messageId, target: targetId, planId, error });
       return null;
     }
     if (!agent.ready) {
@@ -1086,10 +1357,12 @@ export class Room {
         await this.#alert('plan-long', `The plan by @${plan.orchestrator} has been running for ${Math.round((Date.now() - plan.startedAt) / 60000)} min. STOPALL halts it.`, `plan-long:${plan.planId}`);
       }
     }
-    await this.#emit('agent.started', { messageId, agent: agent.id, handoffId, planId });
+    // The limit this turn will be held to, said with its start so the room counts down from the
+    // real number and not from a default it guessed.
+    await this.#emit('agent.started', { messageId, agent: agent.id, handoffId, planId, timeoutMs: this.timeoutFor(agent.id, { writing: Number(mode) >= 2 || Boolean(lease) }) });
     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, ash, mode, escalation });
+    turn.promise = this.#runTurn({ messageId, agent, text, requester, depth, planId, allowDelegation, context, recall, memories, handoffId, signal: controller.signal, model, effort, attachments, references, lease, ash, mode, escalation });
     this.#turns.set(messageId, turn);
     let outcome = null;
     try {
@@ -1106,10 +1379,9 @@ export class Room {
     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.
+  // What the next turn to an agent would carry, built without starting a process or counting a
+  // memory read. Signed linked notes for BISHOP are fetched only on send, so the preview marks
+  // that one dynamic part instead of spending a contract's hourly reading allowance here.
   async briefing({ agent: agentId, mode = 1, text = '', ash = false } = {}) {
     const agent = this.#agents.find((one) => one.id === agentId && one.detected);
     if (!agent) return null;
@@ -1123,6 +1395,9 @@ export class Room {
     const mcpServers = this.#toolsForTurn && agent.adapter !== 'madre-local'
       ? await this.#toolsForTurn({ agent: agent.id, mode, lease: null, scratchDir: null }).catch(() => [])
       : [];
+    const bishop = this.#bishopForTurn ? await this.#bishopForTurn({ agent: agent.id, mode, text, preview: true }).catch(() => null) : null;
+    // Recall from links reads the other room when the turn runs; the preview only says it will.
+    const linkedPreview = this.#linkedForTurn && agent.adapter !== 'madre-local' && mode !== 0 ? await this.#linkedForTurn({ agent: agent.id, mode, text, preview: true }).catch(() => null) : null;
     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
@@ -1145,7 +1420,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: ash === true && this.ashEnabled(), mode, escalation: null, mcpServers,
+      ash: ash === true && this.ashEnabled(), choices: this.#choicesEnabled && mode !== 0, runs: this.#runsEnabled && mode !== 0 && mode < 4, mode, escalation: null, mcpServers, bishop,
     });
     // 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.
@@ -1162,6 +1437,7 @@ export class Room {
       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,
+      dynamic: Boolean(bishop && agent.adapter === 'madre-local') || Boolean(linkedPreview?.dynamic),
     };
   }
 
@@ -1244,7 +1520,7 @@ export class Room {
     });
   }
 
-  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 }) {
+  async #runTurn({ messageId, agent, text, requester, depth, planId, allowDelegation, context, recall = null, memories = null, handoffId, signal, model = null, effort = 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.
@@ -1264,7 +1540,9 @@ export class Room {
       if (this.#controlDesk.holder) {
         await this.#alert('control-busy', `@${this.#controlDesk.holder.agent} still holds CONTROL; @${agent.id} answers read-only this turn.`, `control-busy:${agent.id}`);
       } else {
-        const seat = await this.#controlDesk.begin({ agent, messageId, enabledScopes: enabled, mode });
+        await this.#sayWaitingToWrite({ messageId, agent });
+        const seat = await this.#controlDesk.begin({ agent, messageId, enabledScopes: enabled, mode, signal }).catch((error) => (error?.code === 'ABORT_ERR' ? null : Promise.reject(error)));
+        if (!seat) { await this.#emit('message.failed', { messageId, target: agent.id, planId, error: `Stopped while waiting for the project: another turn was writing in it.`, stopped: true }); return null; }
         controlRun = seat.run;
         lease = seat.lease;
         await this.#emit('control.started', seat.announcement);
@@ -1293,8 +1571,11 @@ export class Room {
       });
     }
     if (lease?.create && !controlRun) {
-      // CREATE: photograph the project now; after the turn only what appeared stays.
-      const seat = await this.#controlDesk.begin({ agent, messageId, enabledScopes: enabled, mode: 2 });
+      // CREATE: photograph the project now; after the turn only what appeared stays. Another turn
+      // writing in the project, in this conversation or another, is waited for first.
+      await this.#sayWaitingToWrite({ messageId, agent });
+      const seat = await this.#controlDesk.begin({ agent, messageId, enabledScopes: enabled, mode: 2, signal }).catch((error) => (error?.code === 'ABORT_ERR' ? null : Promise.reject(error)));
+      if (!seat) { await this.#emit('message.failed', { messageId, target: agent.id, planId, error: `Stopped while waiting for the project: another turn was writing in it.`, stopped: true }); return null; }
       createRun = seat.run;
       // The folder this turn was told to draft in, so settling it does not undo what it was
       // invited to write. Only this turn's own folder; every other `.pulse` path stays forbidden.
@@ -1328,17 +1609,24 @@ export class Room {
       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;
       responseMessageId = randomUUID();
+      this.#liveTurns.set(responseMessageId, { agent: agent.id, mode: turnMode });
       const notesBefore = this.#memory ? this.#memory.maxMemoryId() : 0;
       const others = this.delegatesFor(agent.id);
       const mayDelegate = allowDelegation && this.#delegation && depth === 0;
       // Tools the modules hand to this turn (a browser, say), attached to the CLI for this run only.
       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(() => [])
+        ? await this.#toolsForTurn({ agent: agent.id, mode: turnMode, text, turn: responseMessageId, lease, scratchDir: lease?.scratchDir ? joinPath(this.#projectRoot, lease.scratchDir) : null, servers: this.#runDesk.serving().filter((one) => !one.network).map((one) => one.port) }).catch(() => [])
         : [];
+      const bishop = this.#bishopForTurn ? await this.#bishopForTurn({ agent: agent.id, mode: turnMode, text, turn: responseMessageId }).catch(() => null) : null;
+      // Notes a link with automatic recall brings to this turn (fase 3e): never in GHOST, never for
+      // @madre (its briefing is its own), bounded by the module and counted as readings.
+      const linked = this.#linkedForTurn && agent.adapter !== 'madre-local' && turnMode !== 0
+        ? (await this.#linkedForTurn({ agent: agent.id, mode: turnMode, text, turn: responseMessageId }).catch(() => null))?.text ?? null
+        : null;
       // 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, 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 });
+      const shaped = this.#promptFor({ agent, text, requester, depth, allowDelegation, context, recall, memories, attachments, references, lease, scopes: turnScopes, imageStudio, ash, choices: this.#choicesEnabled && turnMode !== 0, runs: this.#runsEnabled && turnMode !== 0 && turnMode < 4, mode: turnMode, escalation, mcpServers, bishop, linked, 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, servers: [this.#memoryServer?.name, ...mcpServers.map((server) => server.name)].filter(Boolean) });
       // 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);
@@ -1358,28 +1646,49 @@ export class Room {
         projectRoot: this.#projectRoot,
         text,
         prompt: shaped.text,
-        timeoutMs: this.timeoutFor(agent.id),
+        timeoutMs: this.timeoutFor(agent.id, { writing: Boolean(lease) }),
         signal,
         model,
+        effort,
         attachments,
         lease,
         scopes: turnScopes,
         imageStudio,
         memoryServer: memoryServerForTurn(this.#memoryServer, { agent: agent.id, messageId: responseMessageId, mode: turnMode }),
         mcpServers,
+        bishop,
         // For @madre: who asks, who it may convene, and whether a plan would run at all.
         requester,
         crew: others,
         delegation: mayDelegate,
         maxSteps: this.#maxPlanSteps,
+        // And for its closing turn of a round: what each agent asked actually said, with its number.
+        round: agent.id === MADRE_AGENT_ID && planId && /this is your closing turn/i.test(text) ? await this.#roundAnswers(planId) : undefined,
       });
       // Privacy: a private term in a reply is replaced before the ledger, the plan parser,
       // the archivist or any other agent can see it. The reply says how many, not which.
       const guarded = this.#privacy?.redact(result.text ?? '') ?? { text: result.text, hits: 0 };
       if (guarded.hits) result.text = guarded.text;
       // 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 createChanges = createRun ? await this.#controlDesk.settleOrSay(createRun) : null;
+      // Images an agent's own tool made outside the project (Codex keeps them under its home) come
+      // into this turn's draft folder, so they are kept and shown like anything the turn wrote. One
+      // the agent already copied into the project is shown there, not twice.
+      if (createRun?.scratchDir && Array.isArray(result.generatedImages)) {
+        const placed = await this.#bytesOf((createChanges?.files ?? []).filter((file) => file.status === 'A').map((file) => file.path));
+        for (const image of result.generatedImages.slice(0, 8)) {
+          const bytes = await readFileBytes(image).catch(() => null);
+          if (!bytes || placed.some((one) => one.equals(bytes))) continue;
+          await copyFile(image, joinPath(this.#projectRoot, createRun.scratchDir, baseName(image))).catch(() => null);
+        }
+      }
       const artifacts = createChanges ? await this.#artifactsFrom(createChanges.files) : lease && !lease.control ? diffSnapshots(before, await snapshot(lease.outDir), { relativeDir: lease.relativeDir }) : [];
+      // What the turn wrote in its own draft folder. The diff cannot see it in a project that ignores
+      // `.pulse/` (most do, the moment a .gitignore names it), so `/module` wrote its file there and
+      // no install card ever came. The folder is new for this turn: all of it is this turn's.
+      if (createRun?.scratchDir) {
+        for (const drafted of await this.#draftedIn(createRun.scratchDir)) if (!artifacts.some((one) => one.path === drafted.path)) artifacts.push(drafted);
+      }
       // 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
@@ -1396,7 +1705,7 @@ export class Room {
         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 controlChanges = controlRun ? await this.#controlDesk.settleOrSay(controlRun) : null;
       const directives = mayDelegate
         ? parseDirectives(result.text, { self: agent.id, available: others, maxSteps: this.#maxPlanSteps })
         : { steps: [], closing: null, ignored: [] };
@@ -1405,18 +1714,22 @@ export class Room {
         // human sees a plan-shaped reply and nothing happening.
         await this.#emit('plan.ignored', { orchestrator: agent.id, responseMessageId, reasons: directives.ignored.map((item) => item.reason) });
       }
-      if (depth > 0 && /```pulse/i.test(result.text)) {
+      // Only a ```pulse fence is a plan, read the way src/directives.mjs reads it; ```pulse-run,
+      // ```pulse-ask and ```pulse-salas are not (S-029 in docs/MACROVERSO.md).
+      if (depth > 0 && /```pulse\s*\n/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;
+      // Commands it wants the human to run: the same, as buttons. AIRLOCK runs its own.
+      const requested = !asked && this.#runsEnabled && turnMode !== 0 && turnMode < 4 ? parseRunRequest(result.text) : null;
       await this.#emit('message.created', {
         messageId: responseMessageId,
         parentMessageId: messageId,
         role: 'assistant',
         sender: agent.id,
         target: requester,
-        text: asked ? withoutChoice(result.text) : result.text,
+        text: asked ? withoutChoice(result.text) : requested ? withoutRunRequest(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
@@ -1426,6 +1739,7 @@ export class Room {
         status: 'completed',
         planId,
         model,
+        effort: effort ?? undefined,
         synthetic: result.synthetic || undefined,
         redacted: guarded.hits || undefined,
         mode: turnMode,
@@ -1437,8 +1751,9 @@ export class Room {
         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 (asked) await this.#emit('choice.offered', { messageId, responseMessageId, agent: agent.id, question: asked.question, options: asked.options, recommended: asked.recommended ?? undefined, modes: asked.modes ?? undefined });
+      if (requested) await this.#emit('run.requested', { messageId, responseMessageId, agent: agent.id, reason: requested.reason, commands: requested.commands });
+      if (guarded.hits) await this.#emit('privacy.redacted', { agent: agent.id, messageId, responseMessageId, hits: guarded.hits, kinds: guarded.kinds, 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.
@@ -1458,11 +1773,17 @@ export class Room {
         }
       }
       if (controlChanges) await this.#emit('control.changed', { ...controlChanges, responseMessageId });
+      // Codex and OpenCode give tokens, not dollars: the turn is priced at the list price of the
+      // model it ran on (src/prices.mjs), an estimate that says it is one. Gemini prices itself in
+      // its adapter, where its report names each model it used.
+      if (result.usage) result.usage = withListPrice(result.usage, await this.#pricedModel(agent.id, model));
       await this.#recordUsage(agent.id, result.usage, { messageId, responseMessageId });
       await this.#recordCost(agent.id, responseMessageId, result.usage, turnMode);
+      this.#liveTurns.delete(responseMessageId);
       await this.#emit('agent.completed', { messageId, agent: agent.id, handoffId, planId });
       return { responseMessageId, directives };
     } catch (error) {
+      if (responseMessageId) this.#liveTurns.delete(responseMessageId);
       if (responseMessageId && this.#promptShape.has(responseMessageId)) {
         const shape = this.#promptShape.get(responseMessageId);
         this.#promptShape.delete(responseMessageId);
@@ -1471,7 +1792,34 @@ export class Room {
           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 } : {}) });
+      // A CLI that does not know its model says so in its vendor's words, which read like an outage
+      // or a permission problem. MADRE says what it is first; the CLI's own line stays after it,
+      // word for word, so it can still be searched.
+      const said = failureMessage(error);
+      const plain = MODEL_NOT_FOUND.test(String(error?.message ?? error ?? ''))
+        ? `${model ? `${agent.label} does not know the model \`${model}\`.` : `${agent.label} does not know the model it was asked to use.`} Choose another on the model chip beside TO @${agent.id}, or the default; permissions and modes have nothing to do with it. CLI: ${said}`
+        : said;
+      // A turn cut short (the time limit, STOP ALL, a crash) may still have written. What it left is
+      // read and kept the way any turn's is, CREATE still putting back what existed before, and the
+      // failure carries the list and its checkpoint: the first «write the app» was cut at 180 s
+      // with two files of three on disk, and the room said only that Claude did not answer.
+      let partial = null;
+      const writer = controlRun ?? createRun;
+      if (writer) {
+        const changes = await this.#controlDesk.settleOrSay(writer);
+        if (changes.files.length || changes.unreadable || changes.existingReverted.length) {
+          const created = await this.#artifactsFrom(changes.files);
+          partial = { checkpointId: changes.checkpointId, mode: changes.mode, files: changes.files, created, existingReverted: changes.existingReverted, unreadable: changes.unreadable ?? undefined };
+        }
+      }
+      const cutByClock = ['TIMEOUT', 'IDLE'].includes(error?.code);
+      await this.#emit('message.failed', {
+        messageId, target: agent.id, planId,
+        error: this.#privacy ? this.#privacy.redact(plain).text : plain,
+        ...(this.#turns.get(messageId)?.stoppedByHuman ? { stopped: true } : {}),
+        ...(cutByClock ? { timeout: { ms: this.timeoutFor(agent.id, { writing: Boolean(lease) }), writing: Boolean(lease), idle: error.code === 'IDLE' } } : {}),
+        ...(partial ? { partial } : {}),
+      });
       return null;
     } finally {
       // Release CONTROL whichever way the turn ended; the checkpoint stays for UNDO.