@jossuealcala/madre 0.5.1 → 0.6.0

package/src/room.mjs

@@ -33,6 +33,8 @@ import { stat as statFile } from 'node:fs/promises';
 import { basename as baseName, join as joinPath } from 'node:path';
 import { contentTypeFor } from './files.mjs';
 import { isModuleFile, sdkPaths } from './modules/index.mjs';
+import { validateAshReply } from './modules/ash-policy.mjs';
+import { parseChoice, withoutChoice } from './choices.mjs';
 import { imageStudioFor } from './image-studio.mjs';
 import { CAPABILITIES, imageModuleState } from './capabilities.mjs';
 import { resolveReferences } from './files.mjs';
@@ -64,6 +66,34 @@ const CREATION_VERB = /\b(genera(r|d)?|crea(r|d)?|escrib(e|a|ir)|guarda(r)?|prod
 const CREATION_OBJECT = /\b(archivo|fichero|file|pdf|md|markdown|imagen|image|png|jpe?g|svg|documento|document|docx?|csv|json|xlsx?|pptx?|html|script|carpeta|folder|reporte|report|informe|entregable|poster|logo|diagrama|diagram)\b/i;
 export const looksLikeCreation = (text) => CREATION_VERB.test(String(text ?? '')) && CREATION_OBJECT.test(String(text ?? ''));
 
+// Which decisions the project is standing on, out of what the archive holds. A refuted one is
+// kept by the archive — what was once decided is part of the record — and left out here, because
+// a strip that says "decided" cannot carry something the room has since established is false.
+export function settledDecisions(notes = [], { limit = 3 } = {}) {
+  return notes
+    .filter((note) => note && !note.refutedBy)
+    .slice(0, limit)
+    .map((note) => ({ id: note.id, text: note.text, created: note.created, agent: note.agent, fromSequence: note.fromSequence }));
+}
+
+// Open questions the room could put back on the table, newest and most-carried first.
+//
+// `questionsFor` has three wells; this reads only the first. The other two — memories nobody has
+// ever reached for, a kind of note the archive is short of — are about the health of the archive
+// and belong in NOSTROMO beside the map that shows them. What belongs under a composer is the
+// narrower thing: a question this room asked, recorded as open, and never answered.
+//
+// Refuted and dismissed are out. Carried into more turns ranks higher, because a question the
+// room keeps dragging along unanswered is the one most worth asking out loud.
+export function openQuestions(notes = [], { dismissed = [], limit = 3 } = {}) {
+  const skip = new Set(dismissed ?? []);
+  return notes
+    .filter((note) => note && note.kind === 'question' && !note.refutedBy && !skip.has(`open:${note.id}`))
+    .sort((a, b) => (Number(b.recalled ?? 0) - Number(a.recalled ?? 0)) || (b.id - a.id))
+    .slice(0, limit)
+    .map((note) => ({ id: note.id, text: note.text, carried: Number(note.recalled ?? 0) }));
+}
+
 export class Room {
   #store;
   #agents;
@@ -102,6 +132,7 @@ export class Room {
   #maxConcurrentTurns;
   #planMaxAgeMs;
   #ashEnabled = false;
+  #choicesEnabled = false;
 
   constructor({
     store,
@@ -377,6 +408,26 @@ export class Room {
   // opened: a turn in flight is a reason to wait, not something to race.
   working() { return this.#turns.size > 0; }
 
+  // The decisions this project is standing on, newest first.
+  //
+  // Continuity is the point: a conversation opened a week later, or by another agent, starts
+  // knowing what was already settled instead of relitigating it. Read-only, and it costs no
+  // prompt — these never enter a briefing from here, they are shown to the human.
+  //
+  // A refuted decision is left out. The archive keeps it, because what was once decided is part
+  // of the record, but showing it in a strip titled "what we decided" would be the room asserting
+  // something it has since established is false.
+  // The same shape as decisions(): read from the archive, shown to the human, never in a prompt.
+  questions({ limit = 3 } = {}) {
+    if (!this.#memory) return [];
+    return openQuestions(this.#memory.memories({ kind: 'question', limit: limit * 6 }), { dismissed: this.#dismissedAsks(), limit });
+  }
+
+  decisions({ limit = 3 } = {}) {
+    if (!this.#memory) return [];
+    return settledDecisions(this.#memory.memories({ kind: 'decision', limit: limit * 4 }), { limit });
+  }
+
   memoryResearch() {
     if (!this.#memory) return null;
     const memories = this.#memory.memories({ limit: 500 });
@@ -649,7 +700,7 @@ export class Room {
       // Each bill teaches the room what its own words cost, so the next turn can say what it is
       // about to spend before it spends it.
       if (cost.charsPerInputToken) this.#rate = this.#rate ? this.#rate * 0.7 + cost.charsPerInputToken * 0.3 : cost.charsPerInputToken;
-      await this.#emit('turn.cost', { agent, mode, responseMessageId, spared: shape.spared, ...cost });
+      await this.#emit('turn.cost', { agent, mode, responseMessageId, ash: Boolean(cost.blocks.ash), spared: shape.spared, ...cost });
     } catch (error) {
       console.error(`MADRE could not weigh a turn: ${error.message}`);
     }
@@ -693,6 +744,15 @@ export class Room {
     return this.#ashEnabled;
   }
 
+  setChoices(enabled) {
+    this.#choicesEnabled = Boolean(enabled);
+    return this.#choicesEnabled;
+  }
+
+  choicesEnabled() {
+    return this.#choicesEnabled;
+  }
+
   ashEnabled() {
     return this.#ashEnabled;
   }
@@ -772,6 +832,10 @@ export class Room {
   async send({ text, target, model = null, attachments = [], create = false, ash = false, mode = undefined }) {
     const parsed = parseMessage(text, target);
     const requestedMode = normalizeMode(mode, create === true ? 2 : 1);
+    // This is the decision the human made when pressing Send. Capture it before modeCheck() —
+    // the first await — so a concurrent module toggle cannot change the turn after that click.
+    const ashRequested = ash === true;
+    const ashActive = ashRequested && this.#ashEnabled;
     const gate = await this.modeCheck({ target, text, mode: requestedMode });
     if (!gate.ok) throw new Error(gate.error);
     create = requestedMode === 2;
@@ -785,7 +849,6 @@ export class Room {
     // What the human wrote, sent as they wrote it. Ash used to rewrite this line before it left
     // the room; it does not any more, so there is no original to keep beside an abbreviation.
     const text2 = parsed.text || `(${files.length} attached file${files.length === 1 ? '' : 's'})`;
-    const ashActive = ash === true && this.#ashEnabled;
     // "!path" tokens point the agent at project files; only existing files count.
     const references = await resolveReferences(this.#projectRoot, text2);
 
@@ -800,7 +863,7 @@ export class Room {
       sender: 'you',
       target: parsed.target,
       text: text2,
-      ash: ashActive ? { active: true } : undefined,
+      ash: ashRequested ? { requested: true, active: ashActive } : undefined,
       status: 'sent',
       model: chosenModel,
       attachments: files.length ? files.map((file) => ({ id: file.id, name: file.name, fileName: file.fileName, size: file.size, contentType: file.contentType })) : undefined,
@@ -1012,7 +1075,7 @@ export class Room {
   // nowhere. Nothing here counts: a memory read for this was not recalled, the window does not
   // move, and no process is started. It is the document MADRE writes in the human's name, which
   // until now existed only for the instant a CLI was reading it.
-  async briefing({ agent: agentId, mode = 1, text = '' } = {}) {
+  async briefing({ agent: agentId, mode = 1, text = '', ash = false } = {}) {
     const agent = this.#agents.find((one) => one.id === agentId && one.detected);
     if (!agent) return null;
     const priorEvents = await this.#store.readAll();
@@ -1047,7 +1110,7 @@ export class Room {
       context: built.context, recall: built.recall, memories: built.memories,
       attachments: [], references: [], lease,
       scopes: { web: scopes.web.enabled && scopes.web.wired, imageGen: scopes.imageGen.enabled && scopes.imageGen.wired },
-      ash: this.ashEnabled(), mode, escalation: null, mcpServers,
+      ash: ash === true && this.ashEnabled(), mode, escalation: null, mcpServers,
     });
     // Each block with what put it here and what would take it away, so "read, never written" can
     // be checked one block at a time instead of believed.
@@ -1158,6 +1221,7 @@ export class Room {
     let lease = null;
     let controlRun = null;
     let createRun = null;
+    let responseMessageId = null;
     if (mode >= 3 && (requester === 'you' || planId) && depth <= 1 && agentScopes.maxMode >= mode && enabled.write) {
       // CONTROL: the project itself is the writable root, and a checkpoint
       // taken now makes every change of this turn reversible. A plan step gets
@@ -1228,7 +1292,7 @@ export class Room {
       const invoke = this.#invokers[agent.adapter];
       if (!invoke) throw new Error(`${agent.label} does not have a supported MADRE adapter.`);
       const before = lease && !lease.control && !lease.create ? await snapshot(lease.outDir) : null;
-      const responseMessageId = randomUUID();
+      responseMessageId = randomUUID();
       const notesBefore = this.#memory ? this.#memory.maxMemoryId() : 0;
       const others = this.delegatesFor(agent.id);
       const mayDelegate = allowDelegation && this.#delegation && depth === 0;
@@ -1238,7 +1302,7 @@ export class Room {
         : [];
       // The prompt and the shape it was built from: one is sent, the other is kept until the CLI
       // says what it cost, so the bill can be attributed to the blocks that caused it.
-      const shaped = this.#promptFor({ agent, text, requester, depth, allowDelegation, context, recall, memories, attachments, references, lease, scopes: turnScopes, imageStudio, ash, mode: turnMode, escalation, mcpServers, sharedLeaseHint: sharedLease && !lease ? 'A creation lease is active for this plan, but file creation is not enabled for you: answer without creating files and say so if asked to create one.' : null });
+      const shaped = this.#promptFor({ agent, text, requester, depth, allowDelegation, context, recall, memories, attachments, references, lease, scopes: turnScopes, imageStudio, ash, choices: this.#choicesEnabled, mode: turnMode, escalation, mcpServers, sharedLeaseHint: sharedLease && !lease ? 'A creation lease is active for this plan, but file creation is not enabled for you: answer without creating files and say so if asked to create one.' : null });
       this.#promptShape.set(responseMessageId, { parts: shaped.parts, spared: shaped.spared });
       // What this turn is about to read, said while it is still reading it. The size is exact;
       // only the conversion to tokens is an estimate, and it is made at this room's own rate.
@@ -1294,13 +1358,15 @@ export class Room {
       if (depth > 0 && /```pulse/i.test(result.text)) {
         await this.#alert('nested-delegation', `@${agent.id} tried to open a plan from inside a plan. It was ignored; the sequence stays under @${requester}. STOPALL if the room drifts.`, `nested:${agent.id}`);
       }
+      // A question the agent put to the human: it leaves the text and comes back as buttons.
+      const asked = this.#choicesEnabled && turnMode !== 0 ? parseChoice(result.text) : null;
       await this.#emit('message.created', {
         messageId: responseMessageId,
         parentMessageId: messageId,
         role: 'assistant',
         sender: agent.id,
         target: requester,
-        text: result.text,
+        text: asked ? withoutChoice(result.text) : result.text,
         // What the archive handed this turn, so the room can see its own memory working. The
         // whole point of remembering is invisible until the moment it is used.
         recalled: memories?.length
@@ -1317,6 +1383,11 @@ export class Room {
         artifacts: artifacts.length ? artifacts : undefined,
         delegates: directives.steps.length ? directives.steps.map((step) => step.agent) : undefined,
       });
+      if (ash && turnMode !== 0) {
+        const validation = validateAshReply({ request: text, response: result.text });
+        await this.#emit('ash.validated', { messageId, responseMessageId, agent: agent.id, ...validation });
+      }
+      if (asked) await this.#emit('choice.offered', { messageId, responseMessageId, agent: agent.id, question: asked.question, options: asked.options });
       if (guarded.hits) await this.#emit('privacy.redacted', { agent: agent.id, messageId, responseMessageId, hits: guarded.hits, marker: this.#privacy.marker });
       if (artifacts.length) {
         await this.#emit('artifacts.created', { leaseId: lease.leaseId, messageId, responseMessageId, agent: agent.id, outDir: lease.relativeDir, files: artifacts });
@@ -1342,6 +1413,14 @@ export class Room {
       await this.#emit('agent.completed', { messageId, agent: agent.id, handoffId, planId });
       return { responseMessageId, directives };
     } catch (error) {
+      if (responseMessageId && this.#promptShape.has(responseMessageId)) {
+        const shape = this.#promptShape.get(responseMessageId);
+        this.#promptShape.delete(responseMessageId);
+        if (turnMode !== 0) {
+          const cost = turnCost(shape.parts, null);
+          await this.#emit('turn.cost', { agent: agent.id, mode: turnMode, responseMessageId, ash: Boolean(cost.blocks.ash), failed: true, spared: shape.spared, ...cost });
+        }
+      }
       await this.#emit('message.failed', { messageId, target: agent.id, planId, error: this.#privacy ? this.#privacy.redact(failureMessage(error)).text : failureMessage(error) });
       return null;
     } finally {
@@ -1421,18 +1500,21 @@ export class Room {
       if (!plan.stopped && directives.closing) {
         plan.step = directives.steps.length + 1;
         const messageId = randomUUID();
+        const closingMode = ceiling >= 3 ? ceiling : lease ? 2 : 1;
         await this.#emit('message.created', {
           messageId,
           role: 'assistant',
           sender: orchestrator,
           target: orchestrator,
           text: directives.closing,
+          ash: ash ? { active: true } : undefined,
+          mode: closingMode,
           status: 'delegated',
           planId,
           step: plan.step,
           totalSteps: plan.step,
         });
-        await this.#dispatch({ messageId, targetId: orchestrator, text: `${directives.closing}\n(The delegated agents have answered above; this is your closing turn.)`, requester: orchestrator, depth: 1, planId, allowDelegation: false, lease, ash });
+        await this.#dispatch({ messageId, targetId: orchestrator, text: `${directives.closing}\n(The delegated agents have answered above; this is your closing turn.)`, requester: orchestrator, depth: 1, planId, allowDelegation: false, lease, ash, mode: closingMode });
       }
     } finally {
       this.#plans.delete(planId);

package/src/server.mjs

@@ -1,11 +1,15 @@
 import http from 'node:http';
-import { readFile, realpath, writeFile, mkdir, rm } from 'node:fs/promises';
+import { readFile, realpath, writeFile, mkdir, rm, cp, rename, access } from 'node:fs/promises';
 import { rmSync } from 'node:fs';
 import { createHash } from 'node:crypto';
+import { parseListening, probePort, framable } from './ports.mjs';
 import { basename, dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { homedir } from 'node:os';
 import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+
+const execFileAsync = promisify(execFile);
 import { detectAgents, toolsPrefix } from './runtime-detection.mjs';
 import { EventStore } from './event-store.mjs';
 import { RoomMemory } from './memory.mjs';
@@ -58,7 +62,8 @@ import { discoverModels } from './models.mjs';
 import { setImageModule } from './capabilities.mjs';
 import { resolveGeminiKey } from './image-studio.mjs';
 import { commandByName, listCommands, parseCommand } from './commands.mjs';
-import { listDirectory, searchFiles, readServable, storeAttachment, MAX_ATTACHMENT_BYTES } from './files.mjs';
+import { listDirectory, searchFiles, readServable, storeAttachment, resolveInside, MAX_ATTACHMENT_BYTES } from './files.mjs';
+import { planFileOp, CREATIONS } from './file-ops.mjs';
 import { Eyecat } from './eyecat-watch.mjs';
 import { economy } from './room/economy.mjs';
 import { maturity } from './maturity.mjs';
@@ -546,8 +551,8 @@ export async function createPulseServer({
   const startupConfig = await readConfig(root);
   room.setScopes(startupConfig.scopes ?? {});
   setImageModule(startupConfig.modules?.imageStudio ?? {});
-  // Rooms opened before Ash was renamed carry the old key; the human's switch is not lost.
-  room.setAsh(Boolean(startupConfig.modules?.ash?.enabled ?? startupConfig.modules?.ash?.enabled));
+  room.setAsh(Boolean(startupConfig.modules?.ash?.enabled));
+  room.setChoices(Boolean(startupConfig.modules?.choices?.enabled));
   const recoveredTurns = await room.reconcile();
   if (recoveredTurns) console.error(`MADRE recovered ${recoveredTurns} unfinished turn(s) from a previous run.`);
   const quotaMonitor = new QuotaMonitor({
@@ -843,13 +848,17 @@ export async function createPulseServer({
 
   const server = http.createServer(async (request, response) => {
     const url = new URL(request.url, 'http://127.0.0.1');
+    // The project's own folder name, typed by the human. Declared at the top of the handler and
+    // not beside the first route that happened to need it: a const sits in its temporal dead zone
+    // until its own line runs, so any route above it threw instead of refusing.
+    const designationOk = (given) => typeof given === 'string' && given.trim().toLowerCase() === basename(canonicalProjectRoot).toLowerCase();
     try {
       if (request.method === 'GET' && url.pathname === '/') {
         const html = await readFile(join(publicDirectory, 'index.html'));
         response.writeHead(200, { 'content-type': 'text/html; charset=utf-8' });
         return response.end(html);
       }
-      if (request.method === 'GET' && ['/app.js', '/brands.js', '/troubleshooting.js', '/inquiry.js', '/i18n.js', '/es.js', '/resay.js', '/syntax.js'].includes(url.pathname)) {
+      if (request.method === 'GET' && ['/app.js', '/brands.js', '/troubleshooting.js', '/inquiry.js', '/i18n.js', '/es.js', '/resay.js', '/syntax.js', '/routing.js', '/abduction.js'].includes(url.pathname)) {
         const js = await readFile(join(publicDirectory, url.pathname.slice(1)));
         response.writeHead(200, { 'content-type': 'text/javascript; charset=utf-8' });
         return response.end(js);
@@ -859,10 +868,28 @@ export async function createPulseServer({
         response.writeHead(200, { 'content-type': 'text/css; charset=utf-8' });
         return response.end(css);
       }
+      const abductionAssets = new Map([
+        ['/assets/abduction-cat.png', 'abduction-cat.png'],
+        ['/assets/abduction-cat-blink.png', 'abduction-cat-blink.png'],
+        ['/assets/abduction-cat-control-left.png', 'abduction-cat-control-left.png'],
+        ['/assets/abduction-cat-control-right.png', 'abduction-cat-control-right.png'],
+      ]);
+      if (request.method === 'GET' && abductionAssets.has(url.pathname)) {
+        const image = await readFile(join(publicDirectory, 'assets', abductionAssets.get(url.pathname)));
+        response.writeHead(200, {
+          'content-type': 'image/png',
+          'content-length': image.length,
+          'cache-control': 'public, max-age=86400',
+        });
+        return response.end(image);
+      }
       if (request.method === 'GET' && url.pathname === '/api/state') {
         return sendJson(response, 200, {
           projectRoot,
           platform: process.platform,
+          // Which MADRE this is. The page prints it in the corner: the one fact a bug report
+          // always needs and nobody ever remembers to ask for.
+          version: PACKAGE.version,
           // What language this machine set MADRE to, for a browser that has never chosen. It is
           // the language the room is SPEAKING, not the one written in the file: PULSE_LANGUAGE
           // wins over the config here as it does everywhere else, and reading the file again
@@ -872,6 +899,12 @@ export async function createPulseServer({
           chats: await listChats(roomDir),
           agents: agents.map((agent) => ({ ...agent, login: loginPlanFor(agent), install: installPlanFor(agent), key: keyPlanFor(agent.id), ...(accountNoteFor(agent.id) ?? {}) })),
           ash: { enabled: room.ashEnabled() },
+          choices: { enabled: room.choicesEnabled() },
+          // Read live, not from the config this process loaded at boot. A switch the human moves
+          // in MODULES while the room is open has to be the answer the room gives afterwards —
+          // otherwise the switch says on and the browser keeps refusing, which is how a setting
+          // stops being believed.
+          ripleyWeb: Boolean((await readConfig(root)).modules?.ripley?.web),
           ripley: { enabled: await ripleyOn() },
           softTokenBudget,
           timeouts: Object.fromEntries(agents.map((agent) => [agent.id, room.timeoutFor(agent.id)])),
@@ -912,6 +945,37 @@ export async function createPulseServer({
         void broadcastPending();
         return;
       }
+      // Copying and moving, by the human's own hand. Both ends are resolved inside the project
+      // after following symlinks, so no path typed or pasted can reach outside it; the zones the
+      // room guards from agents ask for the project's designation first.
+      if (request.method === 'POST' && url.pathname === '/api/tree/op') {
+        const payload = await body(request).catch(() => ({}));
+        const plan = planFileOp(payload);
+        if (!plan.ok) return sendJson(response, 400, { error: plan.error });
+        if (plan.guarded && !designationOk(payload.designation)) {
+          return sendJson(response, 403, { error: t('UNABLE TO COMPUTE. UNABLE TO CLARIFY.'), guarded: true });
+        }
+        const source = plan.from ? await resolveInside(canonicalProjectRoot, plan.from) : null;
+        if (plan.from && !source) return sendJson(response, 404, { error: t('Not found.') });
+        // The destination does not exist yet, so its PARENT is what has to be inside the project.
+        const targetDir = plan.to.includes('/') ? plan.to.slice(0, plan.to.lastIndexOf('/')) : '.';
+        const parent = await resolveInside(canonicalProjectRoot, targetDir);
+        if (!parent) return sendJson(response, 400, { error: t('The destination is outside this project.') });
+        const destination = join(parent, plan.to.slice(plan.to.lastIndexOf('/') + 1));
+        if (await access(destination).then(() => true, () => false)) {
+          return sendJson(response, 409, { error: t('There is already something at {path}.', { path: plan.to }) });
+        }
+        try {
+          if (plan.operation === 'new-folder') await mkdir(destination);
+          else if (plan.operation === 'new-file') await writeFile(destination, '', { flag: 'wx' });
+          else if (plan.operation === 'copy') await cp(source, destination, { recursive: true, errorOnExist: true, force: false });
+          else await rename(source, destination);
+        } catch (error) {
+          return sendJson(response, 500, { error: error.message });
+        }
+        await room.record(CREATIONS.includes(plan.operation) ? 'project.file.created' : 'project.file.moved', { operation: plan.operation, from: plan.from, to: plan.to, guarded: plan.guarded });
+        return sendJson(response, 200, { ok: true, operation: plan.operation, from: plan.from, to: plan.to });
+      }
       if (request.method === 'GET' && url.pathname === '/api/tree/search') {
         const matches = await searchFiles(canonicalProjectRoot, url.searchParams.get('q') ?? '', { limit: Math.min(Number(url.searchParams.get('limit')) || 20, 50) });
         return sendJson(response, 200, { matches });
@@ -983,7 +1047,6 @@ export async function createPulseServer({
         return sendJson(response, 200, { settings: await applySettings(await body(request)) });
       }
       // NOSTROMO: the archive is behind the project designation, like CONTROL.
-      const designationOk = (given) => typeof given === 'string' && given.trim().toLowerCase() === basename(canonicalProjectRoot).toLowerCase();
       // Sentinel: reports, settings, the manual road (a prefilled issue) and the automatic one.
       if (request.method === 'GET' && url.pathname === '/api/sentinel') {
         return sendJson(response, 200, { reports: sentinel.reports(), settings: sentinel.settings(), environment: sentinel.environment(), feedbackUrl: sentinel.feedbackUrl(), formUrl: sentinel.formUrl() });
@@ -1017,6 +1080,62 @@ export async function createPulseServer({
       }
       // Where this room's tokens go: what each block of the briefing has cost, how much came back
       // from a CLI's own cache, and how many characters the room spends per token it is charged.
+      // What this project has settled, for the strip at the top of a conversation. Not gated
+      // behind the designation the archive is: these same sentences already appear in the room
+      // under any answer that recalled one.
+      // Open questions, for the strip under the composer. Read-only and ungated for the same
+      // reason the decisions are: these sentences already appear in the room whenever one is
+      // recalled. Dismissing one still happens in NOSTROMO, behind the designation.
+      // What is listening on loopback that answers HTTP, for RIPLEY's address bar. Reading only:
+      // lsof reports and changes nothing, nothing in the project is run, and a port that does not
+      // speak HTTP never reaches the list. Starting a server is not here — that runs a command.
+      // Whether an address agrees to be put behind glass. A page is entitled to refuse, and most
+      // serious ones do; what RIPLEY can do is ask before framing it, so the human gets MADRE's
+      // sentence and a real tab instead of the browser's bare "refused to connect".
+      //
+      // This is the one place the room itself reaches the web, and only after the human turned
+      // the web on and typed the address. The request goes through the same watched fetch as
+      // everything else, so it lands in the outbound log like any other departure.
+      if (request.method === 'GET' && url.pathname === '/api/can-frame') {
+        let target = null;
+        try { target = new URL(url.searchParams.get('url') ?? ''); } catch { return sendJson(response, 400, { error: t('That is not an address.') }); }
+        if (!/^https?:$/.test(target.protocol)) return sendJson(response, 400, { error: t('Only http and https.') });
+        const local = ['127.0.0.1', 'localhost', '[::1]'].includes(target.hostname);
+        if (!local && !(await readConfig(root)).modules?.ripley?.web) {
+          return sendJson(response, 403, { error: t('RIPLEY reaches this computer only · turn the web on in MODULES to open an address outside it') });
+        }
+        try {
+          const controller = new AbortController();
+          const timer = setTimeout(() => controller.abort(), 6000);
+          const probe = await reportFetch(target.href, { signal: controller.signal, redirect: 'follow' });
+          clearTimeout(timer);
+          return sendJson(response, 200, { framable: framable(probe.headers), status: probe.status });
+        } catch (error) {
+          return sendJson(response, 200, { framable: true, status: null, unreachable: true });
+        }
+      }
+      if (request.method === 'GET' && url.pathname === '/api/ports') {
+        if (!(await ripleyOn())) return sendJson(response, 412, { error: t('RIPLEY is off. Enable it in MODULES to render files.') });
+        let listening = [];
+        try {
+          const { stdout } = await execFileAsync('lsof', ['-nP', '-iTCP', '-sTCP:LISTEN'], { timeout: 4000, maxBuffer: 2 * 1024 * 1024 });
+          listening = parseListening(stdout, { self: request.socket.localPort });
+        } catch { return sendJson(response, 200, { ports: [], probed: false }); }
+        const ports = [];
+        for (const found of listening.slice(0, 24)) {
+          const probe = await probePort(found.port, { fetchImpl: reportFetch });
+          if (probe.ok) ports.push({ ...found, status: probe.status, html: probe.html, contentType: probe.contentType, framable: probe.framable });
+        }
+        return sendJson(response, 200, { ports, probed: true });
+      }
+      if (request.method === 'GET' && url.pathname === '/api/questions') {
+        const limit = Math.min(5, Math.max(1, Number(url.searchParams.get('limit') ?? 3) || 3));
+        return sendJson(response, 200, { questions: room.questions({ limit }) });
+      }
+      if (request.method === 'GET' && url.pathname === '/api/decisions') {
+        const limit = Math.min(5, Math.max(1, Number(url.searchParams.get('limit') ?? 3) || 3));
+        return sendJson(response, 200, { decisions: room.decisions({ limit }) });
+      }
       if (url.pathname === '/api/economy' && request.method === 'GET') {
         return sendJson(response, 200, economy(await store.readAll()));
       }
@@ -1212,7 +1331,8 @@ export async function createPulseServer({
         const asked = url.searchParams.get('agent') ?? agents.find((agent) => agent.ready && !agent.local)?.id ?? agents[0]?.id;
         const mode = Math.min(4, Math.max(0, Number(url.searchParams.get('mode') ?? 1) || 0));
         const text = String(url.searchParams.get('text') ?? '').slice(0, 2000);
-        const briefing = await room.briefing({ agent: asked, mode, text });
+        const ash = url.searchParams.get('ash') === 'true';
+        const briefing = await room.briefing({ agent: asked, mode, text, ash });
         if (!briefing) return sendJson(response, 404, { error: `No agent "${asked}" on this computer.` });
         return sendJson(response, 200, {
           ...briefing,