@jossuealcala/madre 0.7.2 → 1.0.1

package/src/room.mjs

@@ -6,16 +6,16 @@ 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';
@@ -28,19 +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, isValidEffort } 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 } from './runs.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
@@ -67,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 }));
 }
@@ -91,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;
@@ -116,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;
@@ -131,6 +145,11 @@ 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;
@@ -154,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 = {},
@@ -162,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;
@@ -175,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;
@@ -183,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.
@@ -228,6 +260,7 @@ 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);
@@ -243,18 +276,28 @@ export class Room {
   async #askForMode({ planId, plan, step, index, totalSteps, orchestrator, parentMessageId, mode = 2 }) {
     const requestId = randomUUID();
     const expiresAt = new Date(Date.now() + this.#escalation.ms).toISOString();
-    const payload = { requestId, planId, agent: step.agent, orchestrator, mode, step: index + 1, totalSteps, text: step.text, expiresAt, message: `@${step.agent} needs #${mode} ${MODES[mode].label} for step ${index + 1}: the plan runs at #1. Grant it once, for the whole plan, or deny.` };
+    const payload = { requestId, planId, agent: step.agent, orchestrator, mode, step: index + 1, totalSteps, text: step.text, expiresAt, message: `@${step.agent} needs #${mode} ${MODES[mode].label} for step ${index + 1}. Grant it once, for the whole plan, or deny.` };
+    const pending = this.#escalation.wait(requestId, payload, plan);
     await this.#emit('mode.requested', payload);
-    const decision = await this.#escalation.wait(requestId, payload, plan);
+    const decision = await pending;
     if (decision.decision === 'deny' || plan.stopped) {
       const reason = plan.stopped ? 'stopped' : decision.reason ?? 'denied';
-      await this.#emit('mode.denied', { requestId, planId, agent: step.agent, mode, step: index + 1, reason, message: reason === 'timeout' ? `No answer in ${Math.round(this.#escalation.ms / 1000)}s: @${step.agent} runs step ${index + 1} at #1.` : reason === 'stopped' ? `The plan was stopped while @${step.agent} waited for #${mode}.` : `Denied: @${step.agent} runs step ${index + 1} at #1 and will say what it could not create.` });
+      await this.#emit('mode.denied', { requestId, planId, agent: step.agent, mode, step: index + 1, reason, message: reason === 'timeout' ? `No answer in ${Math.round(this.#escalation.ms / 1000)}s: @${step.agent} runs step ${index + 1} at #1.` : reason === 'stopped' ? `The plan was stopped while @${step.agent} waited for #${mode}.` : `Denied: @${step.agent} runs step ${index + 1} at #1 and will say what it could not do.` });
       return { scope: null, reason };
     }
+    if (mode >= 3) {
+      await this.#emit('mode.granted', { requestId, planId, agent: step.agent, mode, step: index + 1, scope: decision.decision, message: `#${mode} granted to @${step.agent}${decision.decision === 'plan' ? ' for the rest of the plan' : ' for this step'}.` });
+      return { scope: decision.decision, mode };
+    }
     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,
@@ -271,6 +314,10 @@ 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); }
+  modeRequest(requestId) { return this.#escalation.requestOf(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); }
 
@@ -419,6 +466,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.
   //
@@ -440,6 +500,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 });
@@ -508,7 +578,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') {
@@ -528,7 +598,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.
@@ -658,13 +728,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.
@@ -696,7 +767,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);
   }
 
@@ -716,12 +797,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);
@@ -788,7 +880,7 @@ export class Room {
     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) return { ok: false, status: 409, error: 'A command is already running; wait for it or STOPALL.' };
+    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;
@@ -802,18 +894,36 @@ export class Room {
     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 */ }
-    const result = await this.#runDesk.run({ argv: command.argv, cwd: this.#projectRoot });
-    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, checkpointId: checkpoint?.id, files: changes?.files.length ? changes.files.slice(0, 40) : undefined },
-    });
-    return { ok: true, status: 200, result: { ok: result.ok, exitCode: result.exitCode, sequence: event.sequence } };
+    // 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() {
@@ -844,8 +954,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
@@ -880,6 +993,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');
@@ -892,13 +1007,36 @@ export class Room {
     this.#vectors.stop();
   }
 
-  async send({ text, target, model = null, effort = 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;
@@ -908,10 +1046,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.
-    const chosenEffort = isValidEffort(parsed.target, effort) ? effort : null;
+    // 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'})`;
@@ -927,12 +1077,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,
@@ -958,20 +1113,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,
@@ -990,14 +1150,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, effort: chosenEffort, 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
@@ -1008,13 +1170,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));
   }
@@ -1089,11 +1304,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, effort = null, attachments = [], references = [], lease = null, ash = false, mode = 1, escalation = null }) {
+  async #dispatch({ messageId, targetId, text, requester, depth, planId = null, allowDelegation = true, deferPlan = false, 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) {
@@ -1143,7 +1363,9 @@ 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, effort, attachments, references, lease, ash, mode, escalation });
@@ -1157,16 +1379,26 @@ 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, ash, mode });
+    if (outcome?.directives?.steps.length && !deferPlan) {
+      let next = outcome.directives;
+      let parent = outcome.responseMessageId;
+      const grants = new Map();
+      // The orchestrator may form another wave after seeing the crew's replies. Three waves
+      // bound cost and time; a grant for the plan carries forward, only for its authorized scope.
+      for (let round = 0; next?.steps.length && round < 3; round += 1) {
+        const continued = await this.#runPlan({ orchestrator: agent.id, parentMessageId: parent, directives: next, lease, ash, mode, grants });
+        next = continued?.directives ?? null;
+        parent = continued?.responseMessageId ?? parent;
+        lease = continued?.lease ?? lease;
+      }
+      if (next?.steps.length) await this.#emit('plan.ignored', { orchestrator: agent.id, responseMessageId: parent, reasons: ['The plan reached its three-round limit. Continue with a new message if needed.'] });
     }
     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;
@@ -1180,6 +1412,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
@@ -1202,7 +1437,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(), choices: this.#choicesEnabled && mode !== 0, runs: this.#runsEnabled && mode !== 0 && mode < 4, 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.
@@ -1219,6 +1454,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),
     };
   }
 
@@ -1321,7 +1557,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);
@@ -1350,8 +1588,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.
@@ -1385,17 +1626,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 && turnMode !== 0, runs: this.#runsEnabled && turnMode !== 0 && turnMode < 4, 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);
@@ -1415,7 +1663,7 @@ 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,
@@ -1425,19 +1673,39 @@ export class Room {
         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
@@ -1454,7 +1722,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: [] };
@@ -1463,7 +1731,9 @@ 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.
@@ -1498,9 +1768,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, recommended: asked.recommended ?? undefined });
+      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, marker: this.#privacy.marker });
+      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.
@@ -1520,11 +1790,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);
@@ -1533,7 +1809,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.
@@ -1542,30 +1845,38 @@ export class Room {
     }
   }
 
-  async #runPlan({ orchestrator, parentMessageId, directives, lease = null, ash = false, mode = 1 }) {
+  async #runPlan({ orchestrator, parentMessageId, directives, lease = null, ash = false, mode = 1, grants = new Map() }) {
     const planId = randomUUID();
+    const closing = directives.closing ?? 'Review the delegated answers and the work completed. If more work is needed within the permission already granted by the human, finish your reply with one new pulse plan. If a command requested from the human has not run, say what is waiting. Ask the human only for a decision or a new #3/#4 key.';
     // 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
-    // of what it asked, the ceiling and its own MAX MODE. Without a number it inherits the plan.
+    // of what it asked, the ceiling and its own MAX MODE. Without a number it reads, or creates
+    // while a lease exists: as in 1.0, #3 has to be asked for by name.
     const ceiling = mode >= 3 ? mode : lease ? 2 : 1;
+    // A key for one delegate does not authorize every other provider in the plan, and #4 is never
+    // reached through the human's own #4: a delegate gets it only with its own key.
+    const planGrants = grants;
+    const reach = (agent, asked) => Math.max(asked >= 4 ? Math.min(ceiling, 3) : ceiling, planGrants.get(agent) ?? 0);
+    const askedOf = (step) => normalizeMode(step.mode, lease ? 2 : 1);
     const stepMode = (step) => {
       const scopes = this.scopesFor(step.agent);
-      const asked = normalizeMode(step.mode, lease ? 2 : 1);
-      const granted = Math.min(asked, ceiling, scopes.maxMode);
+      const asked = askedOf(step);
+      const granted = Math.min(asked, reach(step.agent, asked), scopes.maxMode);
       return granted >= 2 && !scopes.write.enabled ? 1 : granted;
     };
-    const plan = { planId, orchestrator, steps: directives.steps, closing: directives.closing, step: 0, stopped: null, startedAt: Date.now() };
+    const plan = { planId, orchestrator, steps: directives.steps, closing, step: 0, stopped: null, startedAt: Date.now() };
     this.#plans.set(planId, plan);
     await this.#emit('plan.created', {
       planId,
       orchestrator,
       parentMessageId,
       steps: directives.steps.map((step) => ({ ...step, mode: stepMode(step) })),
-      closing: directives.closing,
+      closing,
       ignored: directives.ignored,
       mode: ceiling,
       leaseId: lease?.leaseId ?? null,
     });
+    let continuation = null;
     try {
       for (const [index, step] of directives.steps.entries()) {
         if (plan.stopped) break;
@@ -1578,7 +1889,18 @@ export class Room {
         let stepLease = lease;
         let escalation = null;
         const stepScopes = this.scopesFor(step.agent);
-        const wanted = stepMode(step);
+        let wanted = stepMode(step);
+        const askedMode = askedOf(step);
+        // #3/#4 are never granted by an agent's text alone. The room waits for the human's
+        // existing key, even when a lower-mode plan asked for a stronger delegate.
+        if (askedMode >= 3 && (askedMode > reach(step.agent, askedMode) || askedMode > stepScopes.maxMode)) {
+          const outcome = await this.#askForMode({ planId, plan, step, index, totalSteps: directives.steps.length + 1, orchestrator, parentMessageId, mode: askedMode });
+          if (outcome.scope === 'plan') planGrants.set(step.agent, askedMode);
+          if (outcome.scope) wanted = Math.min(askedMode, this.scopesFor(step.agent).maxMode);
+          // Denied or unanswered, the step reads, as the line in the room says.
+          else { escalation = outcome.reason; wanted = 1; }
+          if (plan.stopped) break;
+        }
         // Under a #3 ceiling the orchestrator's word is enough: a #2 step gets its project lease,
         // a #3 step gets CONTROL for its turn. Under #1 a creation step still asks the human.
         if (ceiling >= 3 && !stepLease && wanted === 2) {
@@ -1587,8 +1909,8 @@ export class Room {
           stepLease.scopes = Object.fromEntries(SCOPES.map((scope) => [scope, stepScopes[scope].enabled && stepScopes[scope].wired]));
           await this.#emit('lease.granted', { delegated: true, leaseId: stepLease.leaseId, messageId, agent: step.agent, outDir: '.', scratchDir: stepLease.scratchDir, grantedBy: orchestrator, scopes: SCOPES.filter((scope) => stepLease.scopes[scope]), unavailable: [], planId });
         }
-        if (ceiling < 3 && !lease && !stepScopes.write.always && (wanted >= 2 || looksLikeCreation(step.text)) && stepScopes.maxMode >= 2 && stepScopes.write.enabled) {
-          const outcome = await this.#askForMode({ planId, plan, step, index, totalSteps: directives.steps.length + (directives.closing ? 1 : 0), orchestrator, parentMessageId, mode: 2 });
+        if (ceiling < 3 && !lease && !stepScopes.write.always && askedMode < 3 && (askedMode >= 2 || looksLikeCreation(step.text)) && stepScopes.maxMode >= 2 && stepScopes.write.enabled) {
+          const outcome = await this.#askForMode({ planId, plan, step, index, totalSteps: directives.steps.length + 1, orchestrator, parentMessageId, mode: 2 });
           if (outcome.scope === 'plan') lease = outcome.lease;
           if (outcome.scope) stepLease = outcome.lease; else escalation = outcome.reason;
           if (plan.stopped) break;
@@ -1605,20 +1927,21 @@ export class Room {
           mode: wanted >= 3 ? wanted : stepLease && stepScopes.write.enabled ? 2 : 1,
           escalation: escalation ?? undefined,
           step: index + 1,
-          totalSteps: directives.steps.length + (directives.closing ? 1 : 0),
+          totalSteps: directives.steps.length + 1,
         });
         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) {
+      if (!plan.stopped) {
         plan.step = directives.steps.length + 1;
         const messageId = randomUUID();
+        // A delegate's newly granted #3/#4 never raises the orchestrator's own mode.
         const closingMode = ceiling >= 3 ? ceiling : lease ? 2 : 1;
         await this.#emit('message.created', {
           messageId,
           role: 'assistant',
           sender: orchestrator,
           target: orchestrator,
-          text: directives.closing,
+          text: closing,
           ash: ash ? { active: true } : undefined,
           mode: closingMode,
           status: 'delegated',
@@ -1626,7 +1949,10 @@ 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, ash, mode: closingMode });
+        const responseMessageId = await this.#dispatch({ messageId, targetId: orchestrator, text: `${closing}\n(The delegated agents have answered above; this is your closing turn.)`, requester: orchestrator, depth: 0, planId, allowDelegation: true, deferPlan: true, lease, ash, mode: closingMode });
+        const reply = responseMessageId ? (await this.#store.readAll()).find((event) => event.type === 'message.created' && event.payload?.messageId === responseMessageId)?.payload?.text : null;
+        const parsed = reply ? parseDirectives(reply, { self: orchestrator, available: this.delegatesFor(orchestrator), maxSteps: this.#maxPlanSteps }) : null;
+        if (parsed?.steps.length && JSON.stringify(parsed.steps) !== JSON.stringify(directives.steps)) continuation = { responseMessageId, directives: parsed, lease };
       }
     } finally {
       this.#plans.delete(planId);
@@ -1637,5 +1963,6 @@ export class Room {
         reason: plan.stopped ?? null,
       });
     }
+    return continuation;
   }
 }