@poodle64/librarian 2026.9.28 → 2026.10.1

package/dist/chat.svelte.js

@@ -1,8 +1,8 @@
 /**
- * The page's controller: one conversation with one agent, over a room's routes
- * or a job's watch, message and stop.
+ * The page's controller: one conversation with one agent, over a persona's
+ * chat routes or a job's watch, message and stop.
  *
- * A room is asked. Each question streams its own turn, the agent names the
+ * A persona is asked. Each question streams its own turn, the agent names the
  * conversation on its `init` event, and the conversation is read back whole
  * when it is reopened. The turn belongs to the server, not the page: a
  * refresh, a locked phone or a closed tab leaves it running, so a reopened
@@ -20,7 +20,6 @@
  * what its client returns straight through.
  */
 import { untrack } from 'svelte';
-import { isQueued } from './client';
 import { Session } from './session.svelte';
 import { fold, foldState } from './transcript.svelte';
 /** The events of a run: the agent has the question. */
@@ -34,8 +33,6 @@ export class Chat {
     /** When an answer this page is not streaming began, epoch ms: a
      *  conversation reopened mid-answer. */
     answering = $state(null);
-    /** The agent is answering somebody else's question first. */
-    waiting = $state(false);
     /** Today's allowance; null until read, and in a job. */
     quota = $state(null);
     /** The open conversation, or the job; null for a new one. The host keeps
@@ -44,7 +41,7 @@ export class Chat {
     /** This person's conversations, as `list()` last read them; null until then. */
     conversations = $state(null);
     listFailed = $state(false);
-    #room = null;
+    #chat = null;
     #job = null;
     #pollMs;
     #rewatchMs;
@@ -71,7 +68,7 @@ export class Chat {
         if ('watch' in transport)
             this.#job = transport;
         else
-            this.#room = transport;
+            this.#chat = transport;
         this.#pollMs = options.pollMs ?? 5000;
         this.#rewatchMs = options.rewatchMs ?? 2000;
         this.#artefact = options.artefact;
@@ -95,7 +92,7 @@ export class Chat {
     get busy() {
         return this.running || this.answering !== null;
     }
-    /** A job reads what the reader says while it works; a room waits for its answer. */
+    /** A job reads what the reader says while it works; a persona waits for its answer. */
     get sendWhileRunning() {
         return this.#job !== null;
     }
@@ -119,7 +116,7 @@ export class Chat {
         void this.refreshQuota();
         const mine = this.#generation;
         try {
-            const read = await this.#room.read(id);
+            const read = await this.#chat.read(id);
             if (mine === this.#generation)
                 this.#show(read, mine);
             return mine === this.#generation;
@@ -147,11 +144,11 @@ export class Chat {
     }
     /**
      * Ask `question`, or what is in the box, as a `kind` of turn when it is not
-     * a plain question, at a `depth` when the host offers the choice. Resolves
+     * a plain question, narrowed to one `collection` by name when given. Resolves
      * once the turn settles: true if it was asked, false if it was refused,
      * here or by the server, in which case typed words go back into the box.
      */
-    async ask(question, kind, depth) {
+    async ask(question, kind, collection) {
         const typed = question === undefined;
         const text = (question ?? this.draft).trim();
         if (!text)
@@ -165,14 +162,14 @@ export class Chat {
             this.draft = '';
             this.files = [];
         }
-        return this.#ask(text, files, typed, kind, depth);
+        return this.#ask(text, files, typed, kind, collection);
     }
     /** The last question again, as a new turn: the conversation is append-only,
-     *  because the agent's transcript is. Same kind, same depth. */
+     *  because the agent's transcript is. Same kind, same collection. */
     again() {
         const last = this.turns.at(-1);
         return last?.question
-            ? this.ask(last.question, last.kind, last.depth)
+            ? this.ask(last.question, last.kind, last.collection)
             : Promise.resolve(false);
     }
     /** Stop the answer being written, wherever it is being written. */
@@ -186,7 +183,6 @@ export class Chat {
         const stream = this.#stream;
         if (stream && this.#running) {
             this.#running = false;
-            this.waiting = false;
             // Before the agent has named a new conversation there is nothing to
             // address a stop to: the stream is read on, unseen, until it does.
             if (!id) {
@@ -194,21 +190,21 @@ export class Chat {
                 return;
             }
             stream.controller.abort();
-            await this.#room.stop(id).catch(() => undefined);
+            await this.#chat.stop(id).catch(() => undefined);
             return;
         }
         if (this.answering !== null && id) {
-            await this.#room.stop(id).catch(() => undefined);
+            await this.#chat.stop(id).catch(() => undefined);
             clearTimeout(this.#poll);
             await this.#settle(id, this.#generation);
         }
     }
     /** Read today's allowance again. One that cannot be read is left as it was. */
     async refreshQuota() {
-        if (!this.#room)
+        if (!this.#chat)
             return;
         try {
-            this.quota = await this.#room.quota();
+            this.quota = await this.#chat.quota();
         }
         catch {
             // A counter that cannot be read costs the counter, never the ask.
@@ -217,10 +213,10 @@ export class Chat {
     /** Read this person's conversations. Read again after every answer once
      *  read at all, so the list follows what they ask. */
     async list() {
-        if (!this.#room)
+        if (!this.#chat)
             return false;
         try {
-            this.conversations = await this.#room.list();
+            this.conversations = await this.#chat.list();
             this.listFailed = false;
             return true;
         }
@@ -231,10 +227,10 @@ export class Chat {
     }
     async rename(id, title) {
         const name = title.trim();
-        if (!name || !this.#room)
+        if (!name || !this.#chat)
             return false;
         try {
-            await this.#room.rename(id, name);
+            await this.#chat.rename(id, name);
         }
         catch {
             return false;
@@ -246,10 +242,10 @@ export class Chat {
     }
     /** Forget a conversation everywhere. The open one, forgotten, leaves a new one. */
     async remove(id) {
-        if (!this.#room)
+        if (!this.#chat)
             return false;
         try {
-            await this.#room.remove(id);
+            await this.#chat.remove(id);
         }
         catch {
             return false;
@@ -265,10 +261,10 @@ export class Chat {
      *  navigated to, so one deleted a moment ago elsewhere is a false here,
      *  not the reader's page replaced by an error body. */
     async download(id) {
-        if (!this.#room)
+        if (!this.#chat)
             return false;
         try {
-            const { name, body } = await this.#room.download(id);
+            const { name, body } = await this.#chat.download(id);
             save(body, name);
             return true;
         }
@@ -279,10 +275,10 @@ export class Chat {
     /** Mark an answer the agent holds. False when it could not be recorded. */
     async mark(turn, verdict) {
         const id = this.conversationId;
-        if (!id || !this.#room?.mark || !this.#held.has(turn.id))
+        if (!id || !this.#chat?.mark || !this.#held.has(turn.id))
             return false;
         try {
-            await this.#room.mark(id, this.#position(turn), verdict);
+            await this.#chat.mark(id, this.#position(turn), verdict);
             return true;
         }
         catch {
@@ -293,10 +289,10 @@ export class Chat {
      *  was not recorded. */
     async share(turn, share) {
         const id = this.conversationId;
-        if (!id || !this.#room?.share || !this.#held.has(turn.id))
+        if (!id || !this.#chat?.share || !this.#held.has(turn.id))
             return false;
         try {
-            turn.shared = (await this.#room.share(id, this.#position(turn), share)) ?? undefined;
+            turn.shared = (await this.#chat.share(id, this.#position(turn), share)) ?? undefined;
             this.#version += 1;
             return true;
         }
@@ -321,10 +317,9 @@ export class Chat {
         this.#watching = false;
         this.#running = false;
         this.answering = null;
-        this.waiting = false;
     }
-    async #ask(text, files, typed, kind, depth) {
-        const room = this.#room;
+    async #ask(text, files, typed, kind, collection) {
+        const chat = this.#chat;
         const mine = this.#generation;
         const stream = { controller: new AbortController(), stopWanted: false };
         this.#stream = stream;
@@ -335,25 +330,23 @@ export class Chat {
             blocks: [],
             outcome: null,
             citations: [],
-            suggestions: [],
             kind,
-            depth,
+            collection,
             artefact: this.#card(kind)
         });
         const live = this.#turns[this.#turns.length - 1];
         const state = foldState();
         this.#running = true;
-        this.waiting = false;
         this.#version += 1;
         const current = () => mine === this.#generation && this.#stream === stream;
         let ending = null;
-        for await (const event of room.ask({
+        for await (const event of chat.ask({
             question: text,
             files,
             resume: this.conversationId,
             signal: stream.controller.signal,
             kind,
-            depth
+            collection
         })) {
             const named = event.type === 'system' && event.subtype === 'init' ? event.session_id : undefined;
             if (stream.stopWanted) {
@@ -365,29 +358,21 @@ export class Chat {
                     this.#held.add(live.id);
                 }
                 stream.controller.abort();
-                await room.stop(named).catch(() => undefined);
+                await chat.stop(named).catch(() => undefined);
                 break;
             }
             if (!current())
                 break;
-            if (isQueued(event)) {
-                this.waiting = true;
-                this.#version += 1;
-                continue;
-            }
-            // Waiting ends when the agent starts, and no other frame says so.
-            if (named || RUN.has(event.type))
-                this.waiting = false;
             if (named) {
                 this.conversationId = named;
                 this.#held.add(live.id);
                 continue;
             }
-            if (event.type === 'library_error' && event.status === 429)
+            if (event.type === 'agent_error' && event.status === 429)
                 ending = 'refused';
-            else if (event.type === 'library_error' && event.status === 409)
+            else if (event.type === 'agent_error' && event.status === 409)
                 ending = 'answering';
-            else if (event.type === 'library_error' && event.dropped && this.conversationId)
+            else if (event.type === 'agent_error' && event.dropped && this.conversationId)
                 ending = 'dropped';
             if (ending)
                 break;
@@ -418,13 +403,13 @@ export class Chat {
         if (ending === 'dropped' && id) {
             // The page lost the stream, not the turn: read where it has got to.
             try {
-                const read = await room.read(id);
+                const read = await chat.read(id);
                 if (current())
                     this.#show(read, mine);
             }
             catch {
                 if (current())
-                    fold(live, state, { type: 'library_error' });
+                    fold(live, state, { type: 'agent_error' });
             }
         }
         this.#finish();
@@ -438,7 +423,6 @@ export class Chat {
     #finish() {
         this.#stream = null;
         this.#running = false;
-        this.waiting = false;
         this.#version += 1;
         void this.refreshQuota();
         if (this.conversations !== null)
@@ -477,7 +461,7 @@ export class Chat {
     async #settle(id, mine) {
         clearTimeout(this.#poll);
         try {
-            const read = await this.#room.read(id);
+            const read = await this.#chat.read(id);
             if (mine !== this.#generation)
                 return;
             this.#show(read, mine);
@@ -508,12 +492,6 @@ export class Chat {
             this.#watching = true;
             try {
                 for await (const event of job.watch(id, signal)) {
-                    if (isQueued(event)) {
-                        this.waiting = true;
-                        continue;
-                    }
-                    if (RUN.has(event.type))
-                        this.waiting = false;
                     session.apply(event);
                 }
             }
@@ -523,7 +501,6 @@ export class Chat {
             if (signal.aborted)
                 return;
             this.#watching = false;
-            this.waiting = false;
             await this.#idle(signal);
         }
     }
@@ -578,7 +555,7 @@ export function storedTurn(conversation, index, stored) {
         outcome: null,
         citations: stored.citations ?? [],
         kind: stored.kind ?? undefined,
-        depth: stored.depth ?? undefined,
+        collection: stored.collection ?? undefined,
         shared: stored.shared ?? undefined
     };
 }

package/dist/citations.d.ts

@@ -1,14 +1,14 @@
 /**
  * Where an answer came from.
  *
- * Two sources, one shape. The library emits a `citations` event after the
- * final assistant text, and that is the real one — it carries a document id,
- * so a chip can open the document. Until it ships everywhere, the same chips
- * are DERIVED from the "## Sources" block Milton already writes, which names
- * a title and a section but no id: those chips render and read, and cannot
+ * Two sources, one shape. The app emits a `citations` event before the
+ * persona's answer, and that is the real one — it carries a document id,
+ * so a chip can open the document. Without one, the same chips are DERIVED
+ * from the "## Sources" block the persona writes, which names a title and a
+ * section but no id: those chips render and read, and cannot
  * open a pane. A derived citation is marked `derived` so the UI can tell.
  */
-import type { LibrarianCopy } from './copy';
+import type { ChatCopy } from './copy';
 export interface Citation {
     n: number;
     document_id: string;
@@ -86,7 +86,7 @@ export declare function formatVerified(iso: string): string | null;
  * A `verified_at` that is present but not a date is treated as no date, for
  * the same reason: what is shown must be what is known.
  */
-export declare function trustMark(citation: Citation, copy: LibrarianCopy): string | null;
+export declare function trustMark(citation: Citation, copy: ChatCopy): string | null;
 /** One addressable slice of a document — the granularity a citation names. */
 export interface DocumentSection {
     anchor: string;

package/dist/citations.js

@@ -1,11 +1,11 @@
 /**
  * Where an answer came from.
  *
- * Two sources, one shape. The library emits a `citations` event after the
- * final assistant text, and that is the real one — it carries a document id,
- * so a chip can open the document. Until it ships everywhere, the same chips
- * are DERIVED from the "## Sources" block Milton already writes, which names
- * a title and a section but no id: those chips render and read, and cannot
+ * Two sources, one shape. The app emits a `citations` event before the
+ * persona's answer, and that is the real one — it carries a document id,
+ * so a chip can open the document. Without one, the same chips are DERIVED
+ * from the "## Sources" block the persona writes, which names a title and a
+ * section but no id: those chips render and read, and cannot
  * open a pane. A derived citation is marked `derived` so the UI can tell.
  */
 /** Inline `[n]` markers, in order of first appearance.
@@ -40,7 +40,7 @@ export function splitSources(markdown) {
     if (!heading || heading.index === undefined)
         return { body: markdown, citations: [] };
     // The block runs to the NEXT heading, not to the end of the answer. Cutting
-    // to the end loses anything Milton wrote after his sources — a closing note,
+    // to the end loses anything the persona wrote after its sources — a closing note,
     // a caveat — and loses it silently, which is the worst way to lose it.
     const after = markdown.slice(heading.index + heading[0].length);
     const next = after.search(/^[ \t]{0,3}#{1,6}[ \t]/m);

package/dist/client.d.ts

@@ -8,21 +8,12 @@
  * event type needs no change on either side.
  */
 import type { Citation } from './citations';
-/**
- * How hard the persona works on one question: a reading budget and a model,
- * both the operator's to set per deployment, never the colleague's concern.
- * `quick` is always the default; `thorough` always means something — a
- * bigger budget on the strongest model the room allows, even where that
- * model is a local one — so a host never has a state where the choice is
- * greyed out or explained away.
- */
-export type Depth = 'quick' | 'thorough';
 /** A Claude Code message, whole. `content` is a plain string only on a user frame. */
 export interface AgentMessage {
     id?: string;
     content?: Array<Record<string, unknown>> | string;
 }
-/** One Claude Code stream event, or one of the library's own frames. Typed
+/** One Claude Code stream event, or one of the app's own frames. Typed
  *  only where we branch on it, and `type` stays open: a new event type needs
  *  no change here. */
 export interface AgentEvent {
@@ -43,7 +34,7 @@ export interface AgentEvent {
             id?: string;
         };
     };
-    /** A whole message; on the library's `queued` frame, its own sentence. */
+    /** A whole message. */
     message?: AgentMessage | string;
     /** A user frame the CLI echoed back as the turn that consumes it starts
      *  (`--replay-user-messages`): the reader's side of a session. */
@@ -60,57 +51,37 @@ export interface AgentEvent {
     /** What a run returned under `--json-schema`, on its `result`. */
     structured_output?: unknown;
     error?: string;
-    /** On a `library_error` this layer raised: the HTTP status of a route that
+    /** On an `agent_error` this layer raised: the HTTP status of a route that
      *  answered and would not stream. 429 is a spent allowance. */
     status?: number;
-    /** On a `library_error` this layer raised: a stream that opened and died
+    /** On an `agent_error` this layer raised: a stream that opened and died
      *  before its terminal frame. The turn may well go on without the page. */
     dropped?: boolean;
     detail?: string;
     tools?: string[];
     model?: string;
-    /**
-     * The payload of the library's own two trailing frames, which share a key
-     * and not a shape: `citations` carries sources, `suggestions` carries
-     * follow-up questions as plain strings. Narrowed on `type` by whoever
-     * reads it (`Transcript.apply`).
-     */
-    items?: Citation[] | string[];
+    /** The sources of a `citations` frame, which the app emits before the
+     *  persona's answer. */
+    items?: Citation[];
     [key: string]: unknown;
 }
-/**
- * The library's word that an ask waits behind somebody else's: repeated at
- * least every 30 s until the agent starts, and what keeps an idle read
- * timeout from firing meanwhile. `message` is the library's own sentence
- * ("another question is being answered; waiting for it to finish"); a page
- * says it in its persona's words (`copy.waiting`).
- */
-export interface QueuedEvent extends AgentEvent {
-    type: 'queued';
-    message: string;
-}
-/** The frame is the library's `queued`, by its type alone. */
-export declare function isQueued(event: AgentEvent): event is QueuedEvent;
 export interface AskOptions {
     question: string;
     resume?: string | null;
-    subtree?: string;
-    /** Collections this question may see. Empty means all of them. */
-    collections?: string[];
-    /** Files Milton reads for this question. Switches the request to multipart. */
+    /** The one collection this question is asked of, by name. Absent asks
+     *  across every collection the person may read. */
+    collection?: string;
+    /** Files the persona reads for this question. Switches the request to multipart. */
     files?: File[];
     /** What kind of turn this ask should become. Absent means an ordinary
      *  question; a host that offers a study artefact sends its own kind
      *  (`'briefing'`) and interprets what comes back accordingly — the wire
      *  vocabulary is the host's own, never a fixed set here. */
     kind?: string;
-    /** How hard the persona should work on this one. Absent asks for
-     *  whatever the route does by default, so a host that never reads
-     *  `Composer`'s `depth` sends exactly what it always has. */
-    depth?: Depth;
     signal?: AbortSignal;
-    /** Where the ask lands. Each app mounts its own ask route. */
-    endpoint?: string;
+    /** Where the ask lands: the persona's ask route,
+     *  `/api/agent/{persona}/ask`. */
+    endpoint: string;
     /** Override for the ambient `fetch`, e.g. a caller-authenticated wrapper. */
     fetch?: typeof fetch;
 }
@@ -120,7 +91,7 @@ export interface AskOptions {
  * It never throws. Every way a stream can fail to open or die half-way through
  * — the network dropping, an expired session redirecting the POST to an
  * identity provider the browser then blocks on CORS, a server closing the
- * connection mid-answer — comes back as one `library_error` event and a
+ * connection mid-answer — comes back as one `agent_error` event and a
  * finished iteration, because a host's loop is what re-enables its Send
  * button. A thrown generator leaves that loop unfinished: Pebblestone's
  * console sat with Send disabled and no message on screen, indefinitely,
@@ -145,6 +116,6 @@ export interface WatchOptions {
  * difference: a clean close with no `result` is not a failure. A run the
  * reader stopped ends exactly that way, and so does a session that is
  * waiting between runs, so only a stream that would not open, or broke,
- * yields `library_error`. Fold the events with `Session`.
+ * yields `agent_error`. Fold the events with `Session`.
  */
 export declare function watch(options: WatchOptions): AsyncGenerator<AgentEvent>;

package/dist/client.js

@@ -7,17 +7,13 @@
  * backend sent, so the Console renders the real thing and a new Claude Code
  * event type needs no change on either side.
  */
-/** The frame is the library's `queued`, by its type alone. */
-export function isQueued(event) {
-    return event.type === 'queued';
-}
 /**
  * The request body for one ask.
  *
  * JSON when there are no files, multipart when there are — one endpoint, two
  * encodings, because a `File` cannot cross a JSON body and base64 would double
  * a 20 MB attachment on the wire for nothing. The multipart field names are
- * the form convention (`collections[]`, `files[]`) rather than the JSON keys.
+ * the form convention (`files[]`) rather than the JSON key.
  *
  * `Content-Type` is deliberately absent for multipart: setting it by hand
  * omits the boundary the browser generates, and the server then reads zero
@@ -32,10 +28,8 @@ function requestInit(options, signal) {
             body: JSON.stringify({
                 question: options.question,
                 resume: options.resume ?? null,
-                subtree: options.subtree ?? '',
-                collections: options.collections ?? [],
-                kind: options.kind,
-                depth: options.depth
+                collection: options.collection,
+                kind: options.kind
             }),
             signal
         };
@@ -44,14 +38,12 @@ function requestInit(options, signal) {
     form.append('question', options.question);
     if (options.resume)
         form.append('resume', options.resume);
-    for (const collection of options.collections ?? [])
-        form.append('collections[]', collection);
+    if (options.collection)
+        form.append('collection', options.collection);
     for (const file of options.files)
         form.append('files[]', file, file.name);
     if (options.kind)
         form.append('kind', options.kind);
-    if (options.depth)
-        form.append('depth', options.depth);
     return { method: 'POST', credentials: 'include', body: form, signal };
 }
 /**
@@ -60,7 +52,7 @@ function requestInit(options, signal) {
  * It never throws. Every way a stream can fail to open or die half-way through
  * — the network dropping, an expired session redirecting the POST to an
  * identity provider the browser then blocks on CORS, a server closing the
- * connection mid-answer — comes back as one `library_error` event and a
+ * connection mid-answer — comes back as one `agent_error` event and a
  * finished iteration, because a host's loop is what re-enables its Send
  * button. A thrown generator leaves that loop unfinished: Pebblestone's
  * console sat with Send disabled and no message on screen, indefinitely,
@@ -71,7 +63,7 @@ function requestInit(options, signal) {
  * where the turn is rendered.
  */
 export async function* ask(options) {
-    yield* read(() => (options.fetch ?? fetch)(options.endpoint ?? '/api/agent/ask', requestInit(options, options.signal)), options.signal, true);
+    yield* read(() => (options.fetch ?? fetch)(options.endpoint, requestInit(options, options.signal)), options.signal, true);
 }
 /**
  * Async-iterate a session somebody else started: every event from the first,
@@ -81,7 +73,7 @@ export async function* ask(options) {
  * difference: a clean close with no `result` is not a failure. A run the
  * reader stopped ends exactly that way, and so does a session that is
  * waiting between runs, so only a stream that would not open, or broke,
- * yields `library_error`. Fold the events with `Session`.
+ * yields `agent_error`. Fold the events with `Session`.
  */
 export async function* watch(options) {
     yield* read(() => (options.fetch ?? fetch)(options.endpoint, {
@@ -101,7 +93,7 @@ async function* read(open, signal, terminal) {
         // A reader who pressed stop asked for this one; it is not a failure.
         if (signal?.aborted)
             return;
-        yield { type: 'library_error' };
+        yield { type: 'agent_error' };
         return;
     }
     // A session that expired mid-conversation is the shape this catches: the
@@ -115,11 +107,11 @@ async function* read(open, signal, terminal) {
     // check at the end of this function catches it if it really says nothing.
     const kind = (response.headers.get('content-type') ?? '').toLowerCase();
     if (!response.ok) {
-        yield { type: 'library_error', status: response.status };
+        yield { type: 'agent_error', status: response.status };
         return;
     }
     if (!response.body || (kind && !kind.includes('text/event-stream'))) {
-        yield { type: 'library_error' };
+        yield { type: 'agent_error' };
         return;
     }
     const reader = response.body.pipeThrough(new TextDecoderStream()).getReader();
@@ -157,7 +149,7 @@ async function* read(open, signal, terminal) {
         catch {
             if (signal?.aborted)
                 return;
-            yield { type: 'library_error', dropped: true };
+            yield { type: 'agent_error', dropped: true };
             return;
         }
         if (chunk.done)
@@ -171,7 +163,7 @@ async function* read(open, signal, terminal) {
             const event = parse(frame);
             if (!event)
                 continue;
-            if (event.type === 'result' || event.type === 'library_error')
+            if (event.type === 'result' || event.type === 'agent_error')
                 ended = true;
             yield event;
         }
@@ -182,10 +174,10 @@ async function* read(open, signal, terminal) {
     // finished turn look like one that died.
     const last = parse(buffered);
     if (last) {
-        if (last.type === 'result' || last.type === 'library_error')
+        if (last.type === 'result' || last.type === 'agent_error')
             ended = true;
         yield last;
     }
     if (terminal && !ended && !signal?.aborted)
-        yield { type: 'library_error', dropped: true };
+        yield { type: 'agent_error', dropped: true };
 }

package/dist/components/activity-group/activity-group.svelte

@@ -2,7 +2,7 @@
   A whole investigation, as ONE line the reader can open.
 
   Not a stack. Fifteen tool rows between the question and the first word of the
-  answer is the machine room on show, and a running commentary of "Let me
+  answer is the machinery on show, and a running commentary of "Let me
   check…" is worse: it narrates a mechanism the persona is under instruction
   never to mention. So there is exactly one row in every state — "Working…"
   while it runs, a count of what was done once it settles — and the steps are