@agentorg/cli 0.0.8 → 0.0.9

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

@@ -1,13 +1,21 @@
 /**
  * The looper: the loops of whoever hosts it. Messages come in on threads, which are names its host
  * gives; a thread's messages are kept under `thread/<name>/` in the store. What answers them is a
- * piece of work, with a loop of its own.
+ * piece of work, with a loop of its own, or, when a message needs no work, the main loop.
  *
  * Intake is code. A message in a thread that a piece of work follows is given to that work. One in
- * a thread nothing follows is kept, and the main loop says whose it is: new work, which has the
- * thread's name as its id, or work in a turn now, which then follows that thread too. The main
- * loop makes one decision at a time, and one for a thread on all that waits in it. A piece of
- * work answers in the thread of the newest message it has read.
+ * a thread nothing follows is kept, and the main loop decides on the thread: it answers itself, and
+ * the thread stays no work's; or it says whose the message is, new work, which has the thread's
+ * name as its id, or work there is, in a turn or at rest, which then follows that thread too. The
+ * main loop makes one decision at a time, and one for a thread on all that waits in it. A piece
+ * of work answers in the thread of the newest message it has read.
+ *
+ * One piece of work is stopped by saying so. The main loop may answer a message in a thread
+ * nothing follows by stopping the turn of work it was told of; and it is told of each message that
+ * joins a turn of the work its thread follows, beside that work getting it, to stop that turn if
+ * the message asks. The turn is cut and the work is at rest. What the main loop says of it is
+ * said where the message was: in the work's own record when it joined the turn, for the work to
+ * read next, and otherwise in the asking thread alone, which stays no work's.
  *
  * Turns run side by side, each in a place; the main loop takes none. There are `PLACES` of them,
  * and one more that only work already begun (it has done something) may take, so new work never
@@ -15,31 +23,44 @@
  * order it came. While begun work keeps five turns running, new work goes on waiting. `WAITING`
  * turns may wait; past that a message that would start a turn is refused `busy`.
  *
- * 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. A looper that closes under either, or goes without closing, leaves the
- * mark, and `resume` on the same store goes on with it, once. A turn that ends, fails or is
- * stopped leaves no mark; 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 the main loop together.
+ * A piece of work is marked in the store while a turn of it hasn't ended, and a thread while no
+ * work follows it and it holds messages. A looper that closes under a turn or a decision, or goes
+ * without closing, leaves the mark, and `resume` on the same store goes on with it, once. A turn
+ * that ends, fails or is stopped leaves no mark; a thread the main loop answered, couldn't place,
+ * or was stopped over, waits for its next message, and the main loop is put what it holds.
  */
+import { z } from "zod";
 import { createLoop } from "./loop.js";
-import { createMain, titled } from "./main.js";
-import { createRecord, createThread, messageOf, READS, textOf, userEntry, } from "./record.js";
+import { createMain, stopWord, TOLD, titled } from "./main.js";
+import { createRecord, createThread, head, messageOf, READS, userEntry, } from "./record.js";
 import { codeOf, Refusal, } from "./types.js";
 /** The turns that run at once, not counting the one more for work already begun. */
 export const PLACES = 4;
 /** The turns that may wait for a place at once. */
 export const WAITING = 16;
+/**
+ * What is kept of a piece of work: its title, the threads it follows, and once a turn of it has
+ * ended, when that was, the head of what it last said, and whether that turn failed.
+ */
+const Work = z.object({
+    title: z.string(),
+    follows: z.array(z.string()).min(1),
+    at: z.string().optional(),
+    last: z.string().optional(),
+    failed: z.literal(true).optional(),
+});
 /** Where a thread's record is kept in the looper's store. */
 const recordOf = (thread) => `thread/${encodeURIComponent(thread)}/`;
 /** Where a piece of work is marked while a turn of it hasn't ended. */
 const UNFINISHED = "unfinished/";
 /**
- * Where a thread is marked while messages wait in it for a piece of work to take them: `true`
- * while that is still to happen, so the next start goes on with it, and `false` once it couldn't
- * or was stopped, when the thread's next message does.
+ * Where a thread is marked while it holds messages and no piece of work has taken them: `true`
+ * while the main loop is still to decide on it, or work to take them, so the next start goes on
+ * with it, and `false` once the main loop has answered it, couldn't, or was stopped, when the
+ * thread's next message asks.
  */
 const UNROUTED = "unrouted/";
-/** Where a piece of work's title and the threads it follows are kept. */
+/** Where what is kept of a piece of work is kept. */
 const WORKS = "work/";
 const running = (status) => status.state === "thinking" || status.state === "tool";
 /** The store's keys under `prefix`, as a store of its own. */
@@ -76,17 +97,26 @@ export function createLooper(options) {
         threads.set(name, found);
         return found;
     };
-    /** What is kept of each piece of work the main loop placed, and the work each thread has. */
+    /** What is kept of each piece of work, and the work each thread has. */
     const kept = new Map();
     const followed = new Map();
-    /** The threads that are marked: messages wait in them. */
-    const unrouted = new Set();
+    /**
+     * The threads that are marked, since no work has taken what they hold, each with what its mark
+     * says: whether the next start goes on with it.
+     */
+    const marks = new Map();
+    /** The marked threads in which a message was kept since the main loop last read them. */
+    const unread = new Set();
     const markOf = (thread) => UNROUTED + encodeURIComponent(thread);
-    /** Keep a thread's mark: `again` is whether the next start goes on with what waits there. */
-    const wait = (thread, again) => store.set({ key: markOf(thread), value: again });
-    /** Take a thread's mark off: nothing waits there. */
+    /** Mark a thread: `again` is whether the next start goes on with it. */
+    const wait = (thread, again) => {
+        marks.set(thread, again);
+        return store.set({ key: markOf(thread), value: again });
+    };
+    /** Take a thread's mark off: a piece of work has what it holds, or it holds nothing. */
     const settle = async (thread) => {
-        unrouted.delete(thread);
+        marks.delete(thread);
+        unread.delete(thread);
         await store
             .delete({ key: markOf(thread) })
             .catch((error) => log.warn("A thread's mark couldn't be taken off.", { thread, error: String(error) }));
@@ -173,28 +203,28 @@ export function createLooper(options) {
     const learn = () => {
         if (learned)
             return learned;
-        const attempt = (async () => {
-            const keys = await keysUnder(WORKS);
+        /** What the store holds under `prefix`, a few at a time, each given with its key's last part. */
+        const read = async (prefix, each) => {
+            const keys = await keysUnder(prefix);
             for (let at = 0; at < keys.length; at += READS) {
                 const some = keys.slice(at, at + READS);
                 const values = await Promise.all(some.map((key) => store.get({ key })));
-                some.forEach((key, i) => {
-                    const value = values[i]?.value;
-                    const follows = Array.isArray(value?.follows)
-                        ? value.follows.filter((name) => typeof name === "string")
-                        : [];
-                    if (follows.length === 0) {
-                        log.warn("A piece of work's record didn't read back; it is left out.", { key });
-                        return;
-                    }
-                    const id = decodeURIComponent(key.slice(WORKS.length));
-                    kept.set(id, { title: typeof value?.title === "string" ? value.title : "", follows });
-                    for (const name of follows)
-                        followed.set(name, id);
-                });
+                for (const [i, key] of some.entries())
+                    each(decodeURIComponent(key.slice(prefix.length)), values[i]?.value);
             }
-            for (const key of await keysUnder(UNROUTED))
-                unrouted.add(decodeURIComponent(key.slice(UNROUTED.length)));
+        };
+        const attempt = (async () => {
+            await read(WORKS, (id, value) => {
+                const work = Work.safeParse(value);
+                if (!work.success) {
+                    log.warn("A piece of work's record didn't read back; it is left out.", { id });
+                    return;
+                }
+                kept.set(id, work.data);
+                for (const name of work.data.follows)
+                    followed.set(name, id);
+            });
+            await read(UNROUTED, (thread, value) => void marks.set(thread, value === true));
         })();
         learned = attempt;
         attempt.catch(() => {
@@ -205,14 +235,14 @@ export function createLooper(options) {
     };
     /**
      * The work a thread is followed by, if any: the one the main loop gave it, or its own when it
-     * holds messages and none of them waits.
+     * holds messages and isn't marked.
      */
     const workOf = async (thread) => {
         await learn();
         const work = followed.get(thread);
         if (work !== undefined)
             return work;
-        if (unrouted.has(thread))
+        if (marks.has(thread))
             return undefined;
         return (await threadOf(thread).load()).records.length > 0 ? thread : undefined;
     };
@@ -227,7 +257,7 @@ export function createLooper(options) {
             record,
             /** Whether a turn of it is running, as its mark was last asked to say. */
             marked: false,
-            /** Its mark's writes, one after another. */
+            /** The writes of its mark and of its record, one after another. */
             writes: Promise.resolve(),
             /** Keep its mark, or take it off, after any write before. */
             mark(on) {
@@ -251,8 +281,10 @@ export function createLooper(options) {
                         // looper closing keeps it, for whoever opens the store next.
                         if (on && !held.marked)
                             held.mark(!held.loop.resumed());
-                        else if (!on && held.marked && !closed)
+                        else if (!on && held.marked && !closed) {
                             held.mark(false);
+                            ended(id, status.state === "error");
+                        }
                         held.marked = on;
                         tally();
                     },
@@ -269,6 +301,39 @@ export function createLooper(options) {
     };
     /** A work's title: the main loop's, or its opening line for work begun before it had one. */
     const titleOf = async (id) => kept.get(id)?.title || titled(await of(id).record.opening());
+    /** Keep a work's record as it stands when its turn to be written comes. */
+    const save = (id) => {
+        const work = of(id);
+        const written = work.writes.then(async () => {
+            const record = kept.get(id);
+            if (record)
+                await store.set({ key: WORKS + encodeURIComponent(id), value: record });
+        });
+        work.writes = written.then(() => { }, () => { });
+        return written;
+    };
+    /**
+     * A turn of a piece of work has ended: keep when, the head of what it last said, and whether it
+     * failed, for the main loop to tell of it.
+     */
+    const ended = (id, failed) => {
+        const work = of(id);
+        work.writes = work.writes
+            .then(async () => {
+            const last = await work.record.last();
+            const title = await titleOf(id);
+            // Read after the waits above: a decision may have kept that it follows a thread too.
+            const { failed: _, ...was } = kept.get(id) ?? { title, follows: [id] };
+            kept.set(id, {
+                ...was,
+                at: new Date().toISOString(),
+                ...(last ? { last: head(last.replace(/\s+/g, " ").trim(), TOLD.last) } : {}),
+                ...(failed ? { failed: true } : {}),
+            });
+            await store.set({ key: WORKS + encodeURIComponent(id), value: kept.get(id) });
+        })
+            .catch((error) => log.error("A work's record couldn't be written.", { work: id, error: String(error) }));
+    };
     /** Ask something of a piece of work's loop. */
     const using = (id, ask) => started(ask(of(id).loop));
     /** Work given something as the looper closed, its turn cut before it began: marked like one. */
@@ -290,62 +355,134 @@ export function createLooper(options) {
         line.last = taken.catch(() => { });
         return taken;
     };
-    const main = createMain({
-        model: options.model,
-        chosen: async () => (await options.request()).model,
-        log,
-    });
+    const main = createMain({ model: options.model, request: options.request, log });
+    /** The work there is, as the main loop is told of it: in a turn first, then the latest at rest. */
+    const listed = async () => {
+        const turnOf = (id) => works.get(id)?.loop.turn();
+        // Work that has a record, and work in a turn that has none yet.
+        const ids = new Set([
+            ...kept.keys(),
+            ...[...works.keys()].filter((id) => turnOf(id) !== undefined),
+        ]);
+        const all = await Promise.all([...ids].map(async (id) => {
+            const title = await titleOf(id);
+            return {
+                id,
+                title,
+                turn: turnOf(id),
+                last: kept.get(id)?.last,
+                failed: kept.get(id)?.failed,
+                at: kept.get(id)?.at ?? "",
+            };
+        }));
+        return all
+            .filter(({ title }) => title !== "")
+            .sort((a, b) => Number(b.turn !== undefined) - Number(a.turn !== undefined) ||
+            b.at.localeCompare(a.at) ||
+            a.id.localeCompare(b.id))
+            .slice(0, TOLD.works)
+            .map(({ at: _, ...work }) => work);
+    };
     /**
-     * Have the main loop say whose the messages waiting in a thread are, and keep what it says:
-     * new work of the thread's own, or work in a turn now, which then follows the thread too.
-     * Nothing is decided, and it says so with none, once `cut` says the looper stopped or closed.
+     * Keep that a piece of work follows a thread too, under `title` if it is new: kept before the
+     * thread's messages are taken, so a start in between finds whose they are.
+     */
+    const follow = async (thread, work, title) => {
+        const named = title ?? (await titleOf(work));
+        const was = kept.get(work);
+        kept.set(work, {
+            ...was,
+            title: named,
+            follows: [...new Set([...(was?.follows ?? [work]), thread])],
+        });
+        try {
+            await save(work);
+        }
+        catch (error) {
+            // Not kept: it follows what it did, with whatever a turn's end has written since.
+            const now = kept.get(work);
+            if (was && now)
+                kept.set(work, { ...now, title: was.title, follows: was.follows });
+            else
+                kept.delete(work);
+            throw error;
+        }
+        return work;
+    };
+    /**
+     * Have the main loop decide on a thread nothing follows, and keep what it says: an answer of
+     * its own, which is the thread's next message, and whose what was said there is, which is new
+     * work of the thread's own or work there is, which then follows the thread too; or cut the turn
+     * it says to stop. It gives the work, or none when the main loop only answered or stopped, when
+     * nothing waits for an answer, or once `cut` says the looper stopped or closed.
      */
     const decide = async (thread, cut) => {
         // Read in the thread's line: a message being kept there now is kept first.
-        const texts = await inLine(thread, async () => {
-            const { records } = await threadOf(thread).load();
-            const said = records.flatMap(({ entry }) => (entry.role === "user" ? [textOf(entry)] : []));
+        const read = await inLine(thread, async () => {
+            unread.delete(thread);
+            const read = await threadOf(thread).said();
             // Marked before a message that was never kept: nothing waits.
-            if (said.length === 0)
+            if (read.said.length === 0)
                 await settle(thread);
-            return said;
+            return read;
         });
-        if (texts.length === 0)
+        // Nothing waits for an answer: nothing was said, or the main loop has answered the newest.
+        if (read.said.at(-1)?.role !== "user")
             return undefined;
-        const underway = await Promise.all([...works]
-            .filter(([, { loop }]) => running(loop.state()))
-            .map(async ([id]) => ({ id, title: await titleOf(id) })));
+        const there = await listed();
         if (cut())
             return undefined;
-        const routed = await main.route(texts, underway);
-        if (!routed || cut())
+        const replyId = crypto.randomUUID();
+        const decided = await main.decide(read.said, there, (text) => out.delta(thread, replyId, text));
+        if (!decided || cut())
             return undefined;
-        const work = "work" in routed ? routed.work : thread;
-        const record = {
-            title: "work" in routed ? await titleOf(work) : routed.title,
-            follows: [...new Set([...(kept.get(work)?.follows ?? [work]), thread])],
-        };
-        // Kept before the messages are taken, so a start in between finds whose they are.
-        await store.set({ key: WORKS + encodeURIComponent(work), value: record });
-        kept.set(work, record);
-        followed.set(thread, work);
+        const { placed, stop } = decided;
+        // Stopping is cutting the turn it was told of, if that is still the work's turn. This thread
+        // is answered either way, as the work is not its own: with what the main loop wrote, or with
+        // whether a turn was cut.
+        const cutTurn = stop?.turn !== undefined && (await works.get(stop.work)?.loop.cancel(stop.turn)) === true;
+        const answer = decided.answer ?? (stop ? stopWord(cutTurn) : undefined);
+        // Whose it is is kept first: an answer beside it is never all that is left of a decision.
+        const work = placed &&
+            ("work" in placed
+                ? await follow(thread, placed.work)
+                : await follow(thread, thread, placed.title));
+        try {
+            if (answer !== undefined)
+                // What it said itself is the thread's, kept before any work takes the thread. With
+                // nothing placed and nothing said meanwhile, the thread waits for its next message, not
+                // for the next start; a message said meanwhile is still to be decided on.
+                await inLine(thread, async () => {
+                    const { entry, late } = await threadOf(thread).answer(answer, read.upTo, replyId);
+                    out.message(thread, messageOf(entry));
+                    if (work === undefined && !late)
+                        await wait(thread, false).catch((error) => log.warn("A thread's mark couldn't be written.", { thread, error: String(error) }));
+                });
+        }
+        finally {
+            // Only now is the thread its work's to be sent in: after what the main loop said there,
+            // or couldn't keep. Whose it is stands either way, as it is kept.
+            if (work !== undefined)
+                followed.set(thread, work);
+        }
         return work;
     };
-    /** Decisions are made one at a time, each to its end, so each knows what the last began. */
+    /**
+     * Decisions are made one at a time, each to its end, so each knows what the last began. What
+     * the main loop hears of a message that joined a turn takes its place in the same line.
+     */
     let decided = Promise.resolve();
-    /** The threads a message was kept in while they were being decided or given. */
-    const again = new Set();
     /**
      * Give the messages waiting in a thread to a piece of work: the one it has, or the one the main
      * loop says. One at a time for a thread, on all that waits in it; what is said there meanwhile
-     * goes with them, or is asked about when that has ended without taking it. Once the looper has
+     * goes with them, or is decided on when that has ended without taking it. Once the looper has
      * stopped or closed since this was asked, nothing starts, and what waits goes on waiting.
      */
     const route = (thread) => {
         if (stopped || closed)
             return;
         if (routes.has(thread))
-            return void again.add(thread);
+            return;
         const at = cuts;
         const cut = () => at !== cuts;
         const routing = decided
@@ -359,6 +496,8 @@ export function createLooper(options) {
             await inLine(thread, async () => {
                 if (cut())
                     return;
+                // All that is kept there by now is given: none of it is still to be decided on.
+                unread.delete(thread);
                 if (!(await using(work, (loop) => loop.adopt(thread)))) {
                     // Its work was told to stop first: they wait for the thread's next message.
                     if (!cut())
@@ -374,14 +513,17 @@ export function createLooper(options) {
                 return;
             log.error("A message got no answer.", { thread, error: String(error) });
             out.failed(thread, codeOf(error));
-            // Still waiting: for the thread's next message, not for the next start.
-            if (unrouted.has(thread))
-                await wait(thread, false).catch(() => { });
+            // Still waiting: for the thread's next message, not for the next start; unless one was
+            // kept meanwhile, which is decided on next. In the thread's line, after one being kept.
+            await inLine(thread, async () => {
+                if (marks.has(thread) && !unread.has(thread))
+                    await wait(thread, false);
+            }).catch(() => { });
         })
             .finally(() => {
             routes.delete(thread);
             // Not once it has stopped or closed since: then what waits goes on waiting.
-            if (again.delete(thread) && !cut() && unrouted.has(thread))
+            if (unread.has(thread) && !cut() && marks.has(thread))
                 route(thread);
             tally();
         });
@@ -391,18 +533,20 @@ export function createLooper(options) {
     };
     /** Keep a message in a thread nothing follows, and have it routed, unless a stop came since `at`. */
     const intake = async (thread, text, at) => {
-        const waited = unrouted.has(thread);
-        unrouted.add(thread);
+        const was = marks.get(thread);
         const entry = await (async () => {
             await wait(thread, true);
             const into = threadOf(thread);
             const { record, stored } = into.push(await into.load(), userEntry(text));
             await stored;
+            unread.add(thread);
             return record.entry;
         })().catch(async (error) => {
-            // Not kept: nothing of it waits, unless an earlier message of the thread does.
-            if (!waited)
+            // Not kept: the thread's mark is as it was before it.
+            if (was === undefined)
                 await settle(thread);
+            else
+                await wait(thread, was).catch(() => { });
             throw error;
         });
         out.message(thread, messageOf(entry));
@@ -411,12 +555,54 @@ export function createLooper(options) {
             route(thread);
         return { messageId: entry.id };
     };
+    /**
+     * Tell the main loop of a message said in `thread`, which `work` follows, that joined `turn`
+     * of it: it may only stop that turn, and then what it says is kept in the thread as the work's
+     * to read next. This is beside the message's path, after the decisions asked before it, and
+     * stops nothing once that turn has ended. A message the work takes with a thread, said before
+     * it followed that thread, is not told of. It is not kept: one cut off by a stop, a close or a restart is not
+     * heard, and the worker has the message all the same.
+     */
+    const hear = (thread, work, text, turn) => {
+        if (stopped || closed)
+            return;
+        const at = cuts;
+        const cut = () => at !== cuts;
+        decided = decided
+            .then(async () => {
+            const { loop } = of(work);
+            if (cut() || loop.turn() !== turn)
+                return;
+            const title = await titleOf(work);
+            if (cut() || loop.turn() !== turn)
+                return;
+            const say = await main.hear(text, { id: work, title, turn });
+            if (say === undefined || cut())
+                return;
+            // A line the store refuses is the thread's to be told of: the turn is cut all the same.
+            await loop.cancel(turn, { text: say, thread }).catch((error) => {
+                log.error("What the main loop said as it stopped a turn couldn't be kept.", {
+                    thread,
+                    error: String(error),
+                });
+                out.failed(thread, codeOf(error));
+            });
+        })
+            .catch((error) => log.warn("A message said to work in a turn wasn't heard.", {
+            thread,
+            error: String(error),
+        }));
+    };
     /** Give a message to the work its thread is followed by. */
     const give = async (work, thread, text) => {
-        const sent = await using(work, (loop) => loop.send(text, thread));
+        const { turn, ...sent } = await using(work, (loop) => loop.send(text, thread));
+        // One that joined a turn is that turn's; and the main loop hears of it, to stop the turn if
+        // that is what it asks.
+        if (turn !== undefined)
+            hear(thread, work, text, turn);
         leftAtClose(work);
         // What waited there, its work decided but not begun, went with it.
-        if (unrouted.has(thread) && !routes.has(thread))
+        if (marks.has(thread) && !routes.has(thread))
             await settle(thread);
         return sent;
     };
@@ -453,17 +639,17 @@ export function createLooper(options) {
                 log.warn("A turn that was cut off didn't go on.", { key, error: String(error) });
             }
         }
-        for (const thread of [...unrouted]) {
+        for (const [thread, again] of [...marks]) {
             // Closed meanwhile: what waits keeps its mark, for whoever opens the store next.
             if (closed)
                 return;
+            // Only what was still to go on, and once: whatever comes of it, the next start doesn't.
+            if (!again)
+                continue;
             try {
-                // In the thread's line, so its mark is read and written apart from a message kept there.
+                // In the thread's line, so its mark is written apart from a message kept there.
                 await inLine(thread, async () => {
-                    if (routes.has(thread) || !unrouted.has(thread))
-                        return;
-                    // Only what was still to go on, and once: whatever comes of it, the next start doesn't.
-                    if ((await store.get({ key: markOf(thread) })).value !== true || closed)
+                    if (routes.has(thread) || marks.get(thread) !== true || closed)
                         return;
                     if (going())
                         route(thread);
@@ -495,9 +681,9 @@ export function createLooper(options) {
          * 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.
+         * thread nothing follows, the main loop answers it or 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, text) {
             try {
@@ -508,7 +694,7 @@ export function createLooper(options) {
             }
             const at = cuts;
             // Work known here is asked at once, so a stop that comes after this cuts it too.
-            const known = followed.get(thread) ?? (!unrouted.has(thread) && works.has(thread) ? thread : undefined);
+            const known = followed.get(thread) ?? (!marks.has(thread) && works.has(thread) ? thread : undefined);
             if (known !== undefined && !lines.get(thread)?.waiting)
                 return give(known, thread, text);
             return started(inLine(thread, async () => {
@@ -519,7 +705,7 @@ export function createLooper(options) {
             }));
         },
         /** Stop a piece of work's turn now. A call already running finishes, and its result is kept. */
-        cancel: async (work) => works.get(work)?.loop.cancel(),
+        cancel: async (work) => void (await works.get(work)?.loop.cancel()),
         /** What a piece of work's loop is doing. */
         state: (work) => works.get(work)?.loop.state() ?? { state: "idle" },
         /** A thread's messages before `before`, oldest first, as many as fit `limit`. */
@@ -537,12 +723,13 @@ export function createLooper(options) {
             await Promise.all([...loops.map((loop) => loop.cancel()), main.cancel()]);
             // A message being recorded as this was asked is recorded first, and a call still running ends.
             await Promise.all(starting);
-            await Promise.all(routes.values());
+            await decided;
             await Promise.all(loops.map((loop) => loop.drained()));
+            await Promise.all([...works.values()].map(({ writes }) => writes));
             // What was cut off earlier and hasn't gone on doesn't after a stop either: its marks go.
             // Nor does the next start go on with what waits: a thread's next message does.
             await resume(true)
-                .then(() => Promise.all([...unrouted].map((thread) => wait(thread, false))))
+                .then(() => Promise.all([...marks].flatMap(([thread, again]) => (again ? [wait(thread, false)] : []))))
                 .catch((error) => log.warn("What was cut off couldn't be looked for.", { error: String(error) }));
         },
         /** Take messages again. The turns `stop` cut stay cut. */
@@ -561,12 +748,13 @@ export function createLooper(options) {
         },
         /** Settles when every piece of work's latest turn has written all it will. */
         async settled() {
-            await Promise.all(routes.values());
+            await decided;
             await Promise.all([...works.values()].map(({ loop }) => loop.settled()));
             await Promise.all([...works.values()].map(({ writes }) => writes));
         },
         /** Text the model writes while it answers `requestId`, for the reply it becomes. */
         delta(requestId, text) {
+            main.delta(requestId, text);
             for (const { loop } of works.values())
                 loop.delta(requestId, text);
         },