@agentorg/cli 0.0.7 → 0.0.8

package/README.md

@@ -20,8 +20,8 @@ AgentOrg creates and manages agents. Each part is a program that joins a Hub as
 - `@agentorg/mcp`: the built-in MCP provider, an external Actor exporting `unit.provider@1` as `provider`, and the only code that imports the MCP client (`@modelcontextprotocol/client`). `startMcpProvider({hubUrl, actorId, credential, dir})` runs it; its slot `actors` is bound to `hub.actors@1`. It offers two kinds: `url` attaches to a server over Streamable HTTP, sending `secrets.token` as a bearer token on every request (only over https or to this machine), and `command` starts a local server over stdio, with the basic environment and each of its `secrets` as an environment variable. Each connection joins the Hub as its own Actor exporting `tools@1` as `tools`: `list` and `call` go to the server, a tool's result comes back as text, with `failed` when the tool reported an error, and `changed` fires when the server's tools change or it goes or comes back. While a server is away `list` and `call` are refused `not_connected`, and the provider tries again after a backoff from 1 s doubling to 60 s (starting over after 10 minutes up). `create`'s `secrets` are write-only: the values cross once and go only to the provider's private `dir`, never into `params`, `target`, `detail`, status or a log (what a server prints is scrubbed of them). Each connection's Hub credential, parameters and secrets are kept in that folder, and connections rejoin at its next start. A server started by `command` is an ordinary process with the person's rights, outside the Hub's sandbox.
 - `@agentorg/manager`: management, an external Actor exporting `agents@1`, `connections@1`, `skills@1` and, as `settings`, `agent.settings@1`. `startManager({hubUrl, actorId, credential, dir})` runs it; bound to `hub.actors@1`, `hub.grants@1` and `hub.bindings@1`, it is a manager. A provider of either sort is connected by exposing its export to it: the Hub's slots are the only list. It keeps what the Hub can't know, in its private `dir`: each connection's origin, each agent's provider, creatable, instructions and skills, and the skills as `SKILL.md` folders. Status is read when asked, what a connection is exposed to is the Hub's bindings, and `secrets` go straight to the provider. `agents.create` is all or none: the provider makes the agent, its `settings` are bound, its skills added (one whose name is here keeps the one here), each connection it needs made or picked and exposed under its slot, and its chats exposed to the person; if a step fails, what this creation made is removed. The Hub drops that exposure when an agent comes back offering its chats in another shape, as after an upgrade, so management makes it again each time an agent connects. An agent reads only its own instructions and skills, and only it hears that they changed. `agents.models` and `agents.setModel` pass to the agent's provider, as `start` and `stop` do; stopping an agent is the one way to stop its work.
 - `chatgpt`: the model, a program. It signs in with ChatGPT for the person's plan (`account.login@1`: OpenAI's OAuth for open-source apps, with dynamic registration, PKCE and a verified id_token; refresh tokens rotate, one refresh at a time) and serves `llm.session@1` on that plan through the Responses API, streamed and stored nowhere. The tokens never leave it: never in a reply, an event, a log or a refusal. It never uses an API key or API billing: a usage limit is refused `usage_limit`, with where to manage it. `startChatGPT({hubUrl, actorId, credential, dir})` runs it as an Actor exporting `login` and `session` with no slots at all: the sign-in is in `sign-in.json` in its private `dir` (mode 0600, written through before a change is acknowledged, since a rotated refresh token can't be had again), and it reaches OpenAI over the network directly, https only, with redirects returned as they are. Its tests run against an in-process fake of OpenAI, so none reaches OpenAI.
-- `@agentorg/looper`: an agent's loops, knowing nothing of what hosts them. `createLooper` is given a model client, the tools a request may call, a store for its records and where to say what it does, each as a plain type of its own, and takes a message with the name of the thread it came in on. A thread has its record and its loop: a turn sends the record and the tools to the model, runs what the model calls, and goes on until the model answers or the turn has made 200 calls. Turns of different threads run side by side, four at once, and one more that only a thread already begun may take; a turn past that waits for a place, its message already recorded and said, and while begun threads keep five turns running a new thread goes on waiting. Sixteen turns may wait; past that a message that would start a turn is refused `busy`. A message said in a thread whose turn is running or waiting is recorded and said at once, and that turn takes it at its next model request. A thread is marked in the store while a turn of it hasn't ended: `resume` goes on, once, with each turn that was cut off by a looper closing or going without closing, and the model is told to check what is already done. Stopped, it cuts every turn and takes no message until it is started. It imports no other package of this repository, and a test of its own fails if a file under its `src` does.
-- `assistant`: the agent engine and the bundled agent provider. The engine binds the looper to one agent: a chat is a thread, the model and the tools are the agent's slots, and the records go where the agent's are kept. So an agent works in several chats at once, as the looper's places allow. `startAgentProvider` runs an external Actor exporting `agent.provider@1` as `provider`, which offers one creatable, Assistant. Each agent is its own Actor on its own channel in that process, exporting `chat@1`, with the model behind `model: llm.session@1`, instructions and skills from an optional `settings: agent.settings@1`, and tools from each `tools@1` slot exposed to it. Its chats and model choice stay in the provider's private folder; the model is chosen through the provider's `models` and `setModel`, which name the agent. The agent is `working` while any chat's turn runs or waits. A stopped agent stays on its channel and runs no turn: its chats can still be read, and a message is refused `busy`. A message sent in a chat whose turn is running is recorded and shown at once, and that turn takes it at its next model request. A turn that fails leaves its chat with a `problem`, until that chat's next reply, and a message sent after it starts a turn that reads what went unanswered too. A turn that a restart cut off goes on once when the agent is back, its chat showing one line that says so and its model told to check what is already done; one that ended, failed or was stopped doesn't.
+- `@agentorg/looper`: an agent's loops, knowing nothing of what hosts them. `createLooper` is given a model client, the tools a request may call, a store for its records and where to say what it does, each as a plain type of its own, and takes a message with the name of the thread it came in on. What answers is a piece of work, with a loop of its own: a turn sends the work's messages and the tools to the model, runs what the model calls, and goes on until the model answers or the turn has made 200 calls. A message in a thread that a piece of work follows is given to that work, in code. One in a thread nothing follows is recorded and said at once, and put to the main loop, which makes one model request with one function, `route`, and no other tool: it is told the work that is in a turn now, by id and title, and what has come in (the newest eight messages waiting in the thread, the first 4,000 characters of each), and says that is new work, with a title, or points at one of those, which then follows that thread too. It is told to give a message to work in a turn only when the message points at that work explicitly. It decides for one thread at a time, on all that waits in the thread, keeps nothing between decisions and answers nobody; an answer that calls nothing, or names no work in a turn, starts new work. A message is kept once, in the thread it is shown in; a piece of work reads its own across the threads it follows, in the order it took them, and what comes of a model request is written in the thread of the newest message that request read. Turns of different pieces of work run side by side, four at once, and one more that only work that has already done something may take; a turn past that waits for a place, and while such work keeps five turns running new work goes on waiting. Sixteen turns may wait; past that a message that would start a turn is refused `busy`, or, if it is new work's first, kept and told to have failed `busy`. The main loop takes no place. A message said to work whose turn is running or waiting is recorded and said at once, and that turn takes it at its next model request. A turn that fails tells every thread it had taken a message in. A piece of work is marked in the store while a turn of it hasn't ended, and a thread while messages wait in it: `resume` goes on, once, with each that was cut off by a looper closing or going without closing, and the model of a turn that goes on is told to check what is already done. Messages the main loop couldn't place, or was stopped over, wait for their thread's next message, and all of them are put to it together. Stopped, it cuts every turn and the main loop, and takes no message until it is started. It imports no other package of this repository, and a test of its own fails if a file under its `src` does.
+- `assistant`: the agent engine and the bundled agent provider. The engine binds the looper to one agent: a chat is a thread, the model and the tools are the agent's slots, and the records go where the agent's are kept. A new chat's first message is read by the agent's main loop, which starts new work for it or, when it points at work in a turn, gives it to that work, which reads it with all it holds; a piece of work answers in the chat of the newest message it has read, and the chat is that work's from then on. The main loop's request is the looper's own words and one function: none of the agent's instructions, skills or tools. So an agent works on several things at once, as the looper's places allow. `startAgentProvider` runs an external Actor exporting `agent.provider@1` as `provider`, which offers one creatable, Assistant. Each agent is its own Actor on its own channel in that process, exporting `chat@1`, with the model behind `model: llm.session@1`, instructions and skills from an optional `settings: agent.settings@1`, and tools from each `tools@1` slot exposed to it. Its chats and model choice stay in the provider's private folder; the model is chosen through the provider's `models` and `setModel`, which name the agent. The agent is `working` while its main loop decides or any work's turn runs or waits. A stopped agent stays on its channel and runs no turn: its chats can still be read, and a message is refused `busy`. A message sent in a chat whose work is in a turn is recorded and shown at once, and that turn takes it at its next model request. A message that gets no answer leaves its chat with a `problem`, until that chat's next reply, and a message sent after it is read with what went unanswered. A turn that a restart cut off goes on once when the agent is back, the chat of the message it was answering showing one line that says so and its model told to check what is already done; one that ended, failed or was stopped doesn't.
 
 ## Errors
 

package/dist/node_modules/@agentorg/looper/dist/src/loop.d.ts

@@ -2,18 +2,26 @@
  * A loop: a turn sends its record and the tools to the model, runs each function the model calls,
  * and sends the results back, until the model answers without calling anything, or the turn has
  * made its `MAX_CALLS` calls. A message said while a turn runs is recorded at once, and the turn
- * takes it at its next model request.
+ * takes it at its next model request. A loop is one piece of work's: its messages come in the
+ * threads the work follows, and what comes of a request is kept in the thread of the newest
+ * message that request read.
  */
 import { type LoopRecord } from "./record.js";
 import { type Log, type Model, type Shown, type Status, type Tool } from "./types.js";
 /** A brake on a turn, not a budget: nothing approves a call, and the person can stop it. */
 export declare const MAX_CALLS = 200;
-/** Where a loop says what it does. */
+/** Where a loop says what it does, each message with the thread it is shown in. */
 export interface LoopOut {
-    message(message: Shown): void;
+    message(thread: string, message: Shown): void;
     /** Text of the reply `id` as the model writes it. */
-    delta(id: string, text: string): void;
+    delta(thread: string, id: string, text: string): void;
+    /** What it is doing. */
     status(status: Status): void;
+    /** A message in `thread` got no answer, and why: said before the `error` status. */
+    failed(thread: string, problem: {
+        code: string;
+        message: string;
+    }): void;
 }
 /** A turn's place among the turns running: `entered` settles when it has it, or has left. */
 export interface Place {
@@ -42,18 +50,24 @@ export declare function createLoop(options: {
     log: Log;
 }): {
     /**
-     * Say a message. With no turn it starts one, whose progress is said through `out`. In a turn,
-     * running or waiting for its place, it is recorded and said at once, and the turn takes it at
-     * its next model request.
+     * Say a message in a thread the work follows. With no turn it starts one, whose progress is
+     * said through `out`. In a turn, running or waiting for its place, it is recorded and said at
+     * once, and the turn takes it at its next model request.
      */
-    send: (text: string) => Promise<{
+    send: (text: string, thread: string) => Promise<{
         messageId: string;
     }>;
     /**
-     * Go on with a turn that was cut off before it ended, as by a restart: the thread shows one
-     * line saying so, and the model is told once to check what is already done. Nothing goes on in
-     * a thread with nothing kept, in one that has had a turn since the loop was made, or when a
-     * cancel comes first.
+     * Take the messages waiting in `thread`, which the work has come to follow, as its own, and
+     * answer them: in the turn running, or in one this starts. With none waiting no turn starts.
+     * When a cancel came first nothing is taken, and it says so with `false`.
+     */
+    adopt: (thread: string) => Promise<boolean>;
+    /**
+     * Go on with a turn that was cut off before it ended, as by a restart: the thread it was
+     * answering in shows one line saying so, and the model is told once to check what is already
+     * done. Nothing goes on in work with nothing kept, in work that has had a turn since the loop
+     * was made, or when a cancel comes first.
      */
     resume: () => Promise<void>;
     /** Whether the turn running now goes on from one that was cut off. */

package/dist/node_modules/@agentorg/looper/dist/src/loop.js

@@ -2,9 +2,11 @@
  * A loop: a turn sends its record and the tools to the model, runs each function the model calls,
  * and sends the results back, until the model answers without calling anything, or the turn has
  * made its `MAX_CALLS` calls. A message said while a turn runs is recorded at once, and the turn
- * takes it at its next model request.
+ * takes it at its next model request. A loop is one piece of work's: its messages come in the
+ * threads the work follows, and what comes of a request is kept in the thread of the newest
+ * message that request read.
  */
-import { argumentsOf, head, messageOf } from "./record.js";
+import { argumentsOf, head, messageOf, userEntry } from "./record.js";
 import { capped, runTool } from "./tools.js";
 import { codeOf, Refusal, } from "./types.js";
 /** A brake on a turn, not a budget: nothing approves a call, and the person can stop it. */
@@ -55,7 +57,11 @@ export function createLoop(options) {
             if (current.cancelled)
                 return;
             log.error("A turn failed.", { error: String(error) });
-            status(current, { state: "error", detail: codeOf(error) });
+            // Every thread it took a message in, and the one it was answering in, is told.
+            const detail = codeOf(error);
+            for (const thread of new Set([...current.took, current.thread ?? record.id]))
+                out.failed(thread, detail);
+            status(current, { state: "error", detail });
         })
             .finally(() => {
             current.place?.leave();
@@ -65,9 +71,9 @@ export function createLoop(options) {
             .catch((error) => log.error("A turn's status failed.", { error: String(error) }));
         lastEnded = current.ended;
     };
-    const show = (entry) => out.message(messageOf(entry));
+    const show = ({ entry, thread }) => out.message(thread, messageOf(entry));
     /** A call starting: shown as running, under the id its record will have when it ends. */
-    const running = (call, id) => out.message({
+    const running = (call, id, thread) => out.message(thread, {
         id,
         role: "tool",
         text: `${call.name}: running`,
@@ -78,7 +84,7 @@ export function createLoop(options) {
      * Record a function call with its output, keeping every call paired, as the API needs. Its end
      * is shown even if the record can't be written, so no call is left shown as running.
      */
-    const answered = async (call, result, id, read) => {
+    const answered = async (call, result, id, read, thread) => {
         const entry = {
             role: "tool",
             text: `${call.name}: ${result.ok ? "done" : result.code}`,
@@ -93,10 +99,10 @@ export function createLoop(options) {
             ],
         };
         try {
-            show(await record.append(entry, id, read));
+            show(await record.append(entry, { thread, id, read }));
         }
         catch (error) {
-            out.message(messageOf({
+            out.message(thread, messageOf({
                 ...entry,
                 id,
                 at: new Date().toISOString(),
@@ -109,19 +115,20 @@ export function createLoop(options) {
      * Note calls that won't run, in one message however many there are. They never ran, so the
      * record leaves them out: what the model is sent next holds only calls with their outputs.
      */
-    const skipped = async (calls, code) => {
+    const skipped = async (calls, code, thread) => {
         if (calls.length === 0)
             return;
         const text = calls.length === 1 ? `${calls[0]?.name}: ${code}` : `${calls.length} calls: ${code}`;
-        show(await record.append({ role: "tool", text, items: [] }));
+        show(await record.append({ role: "tool", text, items: [] }, { thread }));
     };
     async function run(current) {
         let calls = 0;
         for (;;) {
             const { instructions, tools, model: chosen } = await options.request();
-            const { items: input, read } = await record.input();
+            const { items: input, read, thread } = await record.input();
             if (current.cancelled)
                 return;
+            current.thread = thread;
             const requestId = crypto.randomUUID();
             const replyId = crypto.randomUUID();
             current.requestId = requestId;
@@ -147,7 +154,7 @@ export function createLoop(options) {
                 show(await record.append({
                     role: "assistant",
                     items: texts.map((content) => ({ type: "message", role: "assistant", content })),
-                }, replyId, read));
+                }, { thread, id: replyId, read }));
             if (called.length === 0) {
                 if (current.cancelled)
                     return;
@@ -174,7 +181,7 @@ export function createLoop(options) {
             for (const [i, call] of called.entries()) {
                 if (current.cancelled || calls >= MAX_CALLS) {
                     const rest = called.slice(i);
-                    await skipped(rest, current.cancelled ? "cancelled" : "limit");
+                    await skipped(rest, current.cancelled ? "cancelled" : "limit", thread);
                     break;
                 }
                 calls++;
@@ -182,9 +189,9 @@ export function createLoop(options) {
                 // A call that has started runs to its end, and its real result is kept: it may have
                 // taken effect.
                 const id = crypto.randomUUID();
-                running(call, id);
+                running(call, id, thread);
                 const result = await runTool(tools, call.name, call.arguments);
-                await answered(call, result, id, read);
+                await answered(call, result, id, read, thread);
             }
             if (current.cancelled)
                 return;
@@ -200,6 +207,8 @@ export function createLoop(options) {
         current.waiting = false;
         if (current.cancelled)
             return;
+        // Where it answers until a request says: so a failure before one names its thread.
+        current.thread = await record.where();
         await run(current);
     }
     /**
@@ -212,14 +221,10 @@ export function createLoop(options) {
         current.place = options.enter(begun);
         current.waiting = true;
     };
-    const said = async (text, joined) => {
-        const entry = await record.append({
-            role: "user",
-            items: [{ type: "message", role: "user", content: text }],
-            ...(joined ? { joined: true } : {}),
-        });
-        show(entry);
-        return { messageId: entry.id };
+    const said = async (text, thread, joined) => {
+        const kept = await record.append({ ...userEntry(text), ...(joined ? { joined: true } : {}) }, { thread });
+        show(kept);
+        return { messageId: kept.entry.id };
     };
     /**
      * Start a turn: `open` takes its place and keeps what opens it, then its loop runs. When `open`
@@ -227,7 +232,7 @@ export function createLoop(options) {
      * runs nothing.
      */
     const start = async (cancelled, open) => {
-        const current = { cancelled };
+        const current = { cancelled, took: new Set() };
         if (!cancelled)
             turn = current;
         began = true;
@@ -251,23 +256,49 @@ export function createLoop(options) {
     };
     return {
         /**
-         * Say a message. With no turn it starts one, whose progress is said through `out`. In a turn,
-         * running or waiting for its place, it is recorded and said at once, and the turn takes it at
-         * its next model request.
+         * Say a message in a thread the work follows. With no turn it starts one, whose progress is
+         * said through `out`. In a turn, running or waiting for its place, it is recorded and said at
+         * once, and the turn takes it at its next model request.
          */
-        send: (text) => inOrder(async (cancelled) => {
-            if (turn)
-                return said(text, true);
+        send: (text, thread) => inOrder(async (cancelled) => {
+            if (turn) {
+                turn.took.add(thread);
+                return said(text, thread, true);
+            }
             return (await start(cancelled, async (current) => {
-                enter(current, !(await record.empty()));
-                return { opened: await said(text, false) };
+                enter(current, await record.begun());
+                current.took.add(thread);
+                return { opened: await said(text, thread, false) };
             }));
         }),
         /**
-         * Go on with a turn that was cut off before it ended, as by a restart: the thread shows one
-         * line saying so, and the model is told once to check what is already done. Nothing goes on in
-         * a thread with nothing kept, in one that has had a turn since the loop was made, or when a
-         * cancel comes first.
+         * Take the messages waiting in `thread`, which the work has come to follow, as its own, and
+         * answer them: in the turn running, or in one this starts. With none waiting no turn starts.
+         * When a cancel came first nothing is taken, and it says so with `false`.
+         */
+        adopt: (thread) => inOrder(async (cancelled) => {
+            if (cancelled)
+                return false;
+            if (turn) {
+                turn.took.add(thread);
+                await record.adopt(thread, true);
+                return true;
+            }
+            await start(false, async (current) => {
+                enter(current, await record.begun());
+                current.took.add(thread);
+                if ((await record.adopt(thread, false)) > 0)
+                    return { opened: undefined };
+                current.place?.leave();
+                return undefined;
+            });
+            return true;
+        }),
+        /**
+         * Go on with a turn that was cut off before it ended, as by a restart: the thread it was
+         * answering in shows one line saying so, and the model is told once to check what is already
+         * done. Nothing goes on in work with nothing kept, in work that has had a turn since the loop
+         * was made, or when a cancel comes first.
          */
         resume: () => inOrder(async (cancelled) => {
             if (began || cancelled)
@@ -277,11 +308,14 @@ export function createLoop(options) {
                     return undefined;
                 enter(current, true);
                 current.resumed = true;
+                // In the thread of the message it was answering.
+                const thread = await record.where();
+                current.took.add(thread);
                 show(await record.append({
                     role: "tool",
                     text: CUT_OFF.shown,
                     items: [{ type: "message", role: "user", content: CUT_OFF.told }],
-                }));
+                }, { thread }));
                 return { opened: undefined };
             });
         }),
@@ -326,7 +360,7 @@ export function createLoop(options) {
         /** Streamed text of the model request running now, for the reply it becomes. */
         delta(requestId, text) {
             if (turn?.requestId === requestId && turn.replyId)
-                out.delta(turn.replyId, text);
+                out.delta(turn.thread ?? record.id, turn.replyId, text);
         },
     };
 }

package/dist/node_modules/@agentorg/looper/dist/src/looper.d.ts

@@ -1,14 +1,21 @@
 import { type Log, type Model, type Shown, type Status, type Store, type Tool } from "./types.js";
-/** The turns that run at once, not counting the one more for a thread already begun. */
+/** The turns that run at once, not counting the one more for work already begun. */
 export declare const PLACES = 4;
 /** The turns that may wait for a place at once. */
 export declare const WAITING = 16;
-/** Where a looper's loops say what they do, each with the thread it is said in. */
+/** Where a looper says what it does. */
 export interface LooperOut {
+    /** A message, with the thread it is shown in. */
     message(thread: string, message: Shown): void;
     /** Text of the reply `id` as the model writes it. */
     delta(thread: string, id: string, text: string): void;
-    status(thread: string, status: Status): void;
+    /** Whether anything is at work, the main loop included: said when it changes. */
+    working(on: boolean): void;
+    /** A message in `thread` got no answer, and why. */
+    failed(thread: string, problem: {
+        code: string;
+        message: string;
+    }): void;
 }
 /**
  * Make a looper. Nothing is read or run until a thread is named: a message sent in it, or its
@@ -32,38 +39,41 @@ export declare function createLooper(options: {
     log: Log;
 }): {
     /**
-     * Say a message in a thread. It is recorded and said at once. With no turn in the thread it
-     * starts one, which waits for a place if none is free; a turn running or waiting takes it at
-     * its next model request. Refused `busy` while `WAITING` turns already wait and it would start
-     * one more, or while the looper is stopped; and `unavailable` once it has closed.
+     * Say a message in a thread. It is recorded and said at once. In a thread a piece of work
+     * follows it is that work's: with no turn of it running it starts one, which waits for a place
+     * if none is free, and a turn running or waiting takes it at its next model request. In a
+     * thread nothing follows, the main loop says whose it is first. Refused `busy` while `WAITING`
+     * turns already wait and it would start one more, or while the looper is stopped; and
+     * `unavailable` once it has closed.
      */
     send(thread: string, text: string): Promise<{
         messageId: string;
     }>;
-    /** Stop a thread's turn now. A call already running finishes, and its result is kept. */
-    cancel: (thread: string) => Promise<void | undefined>;
-    /** What a thread's loop is doing. */
-    state: (thread: string) => Status;
+    /** Stop a piece of work's turn now. A call already running finishes, and its result is kept. */
+    cancel: (work: string) => Promise<void | undefined>;
+    /** What a piece of work's loop is doing. */
+    state: (work: string) => Status;
     /** A thread's messages before `before`, oldest first, as many as fit `limit`. */
     page: (thread: string, before: string | undefined, limit: number) => Promise<{
         messages: Shown[];
         more: boolean;
     }>;
     /**
-     * Stop: every turn is cut, running or waiting, and none starts until `start`. A call already
-     * running finishes first, so this answers when nothing more will be written. The records stay
-     * as they are, to be read. A turn that was cut off earlier no longer goes on.
+     * Stop: every turn is cut, running or waiting, the main loop is cut too, and nothing starts
+     * until `start`. A call already running finishes first, so this answers when nothing more will
+     * be written. The records stay as they are, to be read. What was cut off earlier no longer
+     * goes on, and messages waiting for a piece of work wait for their thread's next.
      */
     stop(): Promise<void>;
     /** Take messages again. The turns `stop` cut stay cut. */
     start(): void;
     resume: () => Promise<void>;
     /**
-     * Close for good: every turn is cut, and none starts after. Each stays marked, for `resume`
-     * in whoever opens the store next.
+     * Close for good: every turn is cut, and none starts after. Each stays marked, as does each
+     * thread where messages wait, for `resume` in whoever opens the store next.
      */
     close(): Promise<void>;
-    /** Settles when every thread's latest turn has written all it will. */
+    /** Settles when every piece of work's latest turn has written all it will. */
     settled(): Promise<void>;
     /** Text the model writes while it answers `requestId`, for the reply it becomes. */
     delta(requestId: string, text: string): void;