@agentorg/cli 0.0.7 → 0.0.9

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

@@ -1,30 +1,68 @@
 /**
- * The looper: the loops of whoever hosts it, one for each thread a message comes in on. A thread is
- * a name its host gives; its record is kept under `thread/<name>/` in the store, and its loop and
- * record are made when the thread is first used and then stay in memory.
+ * 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, or, when a message needs no work, the main loop.
  *
- * Turns run side by side, each in a place. There are `PLACES` of them, and one more that only a
- * thread already begun (its record holds something) may take, so new threads never keep a message
- * from one that is under way. A turn that finds no place waits for one, in the order it came. While
- * begun threads keep five turns running, a new thread goes on waiting. `WAITING` turns may wait;
- * past that a message that would start a turn is refused `busy`, and nothing of it is kept.
+ * 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 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.
  *
- * A thread is marked in the store while a turn of it hasn't ended. A looper that closes under a
- * turn, or goes without closing, leaves the mark, and `resume` on the same store goes on with that
- * turn, once: the turn that goes on is not marked. A turn that ends, fails or is stopped leaves
- * no mark.
+ * 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
+ * keeps a message from work that is under way. A turn that finds no place waits for one, in the
+ * 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 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 { createRecord } from "./record.js";
-import { Refusal, } from "./types.js";
-/** The turns that run at once, not counting the one more for a thread already begun. */
+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 thread is marked while a turn of it hasn't ended. */
+/** Where a piece of work is marked while a turn of it hasn't ended. */
 const UNFINISHED = "unfinished/";
+/**
+ * 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 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. */
 function under(store, prefix) {
     return {
@@ -50,18 +88,52 @@ function under(store, prefix) {
  */
 export function createLooper(options) {
     const { store, out, log } = options;
+    /** The pieces of work that have a loop here, by id. */
+    const works = new Map();
     const threads = new Map();
+    /** A thread's messages, read when first asked for. */
+    const threadOf = (name) => {
+        const found = threads.get(name) ?? createThread(under(store, recordOf(name)), log);
+        threads.set(name, found);
+        return found;
+    };
+    /** 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, 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);
+    /** 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) => {
+        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) }));
+    };
+    /** The threads being decided or given now; each settles when that has ended. */
+    const routes = new Map();
     /** Set while it is stopped: no turn starts until it is started. */
     let stopped = options.stopped ?? false;
     /** Set when it closes: no turn starts after. */
     let closed = false;
-    /** Set once the turns that were cut off have been looked for. */
-    let looked = false;
-    /** Refuse a turn that can't start now, whatever thread it is for. */
-    const mayStart = () => {
+    /** Counts the stops and the close: what was asked before one starts nothing after it. */
+    let cuts = 0;
+    /** Refuse a turn that can't start now, or was asked for before a stop, whatever its thread. */
+    const mayStart = (at = cuts) => {
         if (closed)
             throw new Refusal("unavailable", "This agent is closing.");
-        if (stopped)
+        if (stopped || at !== cuts)
             throw new Refusal("busy", "It is stopped. Start it to go on.");
     };
     /** Messages being recorded now, each about to start a turn: stopping waits for them. */
@@ -71,6 +143,15 @@ export function createLooper(options) {
         starting.add(done);
         return call;
     };
+    /** Whether anything is at work, as it was last said. */
+    let working = false;
+    const tally = () => {
+        const now = routes.size > 0 || [...works.values()].some(({ loop }) => running(loop.state()));
+        if (now === working)
+            return;
+        working = now;
+        out.working(now);
+    };
     /** The turns that have a place, and those waiting for one, first come first. */
     const placed = new Set();
     const waiting = [];
@@ -107,22 +188,82 @@ export function createLooper(options) {
             throw new Refusal("busy", "Too many turns are waiting. Wait for one to start.");
         return place;
     };
-    const open = (thread) => {
-        const record = createRecord(under(store, recordOf(thread)), log);
-        const key = UNFINISHED + encodeURIComponent(thread);
+    /** What the store holds of the work the main loop placed, and of what waits: read once. */
+    let learned;
+    const keysUnder = async (prefix) => {
+        const keys = [];
+        let after;
+        do {
+            const page = await store.list({ prefix, ...(after ? { after } : {}) });
+            keys.push(...page.keys);
+            after = page.next ?? undefined;
+        } while (after);
+        return keys;
+    };
+    const learn = () => {
+        if (learned)
+            return learned;
+        /** 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 })));
+                for (const [i, key] of some.entries())
+                    each(decodeURIComponent(key.slice(prefix.length)), values[i]?.value);
+            }
+        };
+        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(() => {
+            if (learned === attempt)
+                learned = undefined;
+        });
+        return attempt;
+    };
+    /**
+     * The work a thread is followed by, if any: the one the main loop gave it, or its own when it
+     * holds messages and isn't marked.
+     */
+    const workOf = async (thread) => {
+        await learn();
+        const work = followed.get(thread);
+        if (work !== undefined)
+            return work;
+        if (marks.has(thread))
+            return undefined;
+        return (await threadOf(thread).load()).records.length > 0 ? thread : undefined;
+    };
+    const open = (id) => {
+        const record = createRecord({
+            id,
+            follows: () => kept.get(id)?.follows ?? [id],
+            thread: threadOf,
+        });
+        const key = UNFINISHED + encodeURIComponent(id);
         const held = {
             record,
-            /** What is being asked of its loop now: messages, going on. */
-            uses: 0,
             /** 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) {
                 held.writes = held.writes
                     .then(() => (on ? store.set({ key, value: true }) : store.delete({ key })))
-                    .then(() => { }, (error) => log.error("A thread's mark couldn't be written.", { thread, error: String(error) }));
+                    .then(() => { }, (error) => log.error("A work's mark couldn't be written.", { work: id, error: String(error) }));
             },
             loop: createLoop({
                 request: options.request,
@@ -130,19 +271,22 @@ export function createLooper(options) {
                 enter,
                 record,
                 out: {
-                    message: (message) => out.message(thread, message),
-                    delta: (id, text) => out.delta(thread, id, text),
+                    message: out.message,
+                    delta: out.delta,
+                    failed: out.failed,
                     status(status) {
-                        const running = status.state === "thinking" || status.state === "tool";
+                        const on = running(status);
                         // A turn that starts is marked, but one that goes on from a cut-off has that mark
                         // taken off: it goes on once. A turn that ends takes its mark off, but one cut by the
                         // looper closing keeps it, for whoever opens the store next.
-                        if (running && !held.marked)
+                        if (on && !held.marked)
                             held.mark(!held.loop.resumed());
-                        else if (!running && held.marked && !closed)
+                        else if (!on && held.marked && !closed) {
                             held.mark(false);
-                        held.marked = running;
-                        out.status(thread, status);
+                            ended(id, status.state === "error");
+                        }
+                        held.marked = on;
+                        tally();
                     },
                 },
                 log,
@@ -150,66 +294,344 @@ export function createLooper(options) {
         };
         return held;
     };
+    const of = (id) => {
+        const found = works.get(id) ?? open(id);
+        works.set(id, found);
+        return found;
+    };
+    /** 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. */
+    const leftAtClose = (id) => {
+        const work = works.get(id);
+        if (closed && work && !work.marked)
+            work.mark(true);
+    };
+    /**
+     * What is asked of a thread whose work has to be found, or is being given it, taken one at a
+     * time in the order it was asked; and how much is still to be taken.
+     */
+    const lines = new Map();
+    const inLine = (thread, take) => {
+        const line = lines.get(thread) ?? { last: Promise.resolve(), waiting: 0 };
+        lines.set(thread, line);
+        line.waiting++;
+        const taken = line.last.then(take).finally(() => void line.waiting--);
+        line.last = taken.catch(() => { });
+        return taken;
+    };
+    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);
+    };
     /**
-     * Ask something of a thread's loop. A thread first named by an ask that fails, with nothing else
-     * asked of it meanwhile, was never used: nothing is held for it.
+     * 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 using = async (thread, ask) => {
-        const known = threads.has(thread);
-        const held = of(thread);
-        held.uses++;
+    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 {
-            return await started(ask(held.loop));
+            await save(work);
         }
         catch (error) {
-            if (!known && held.uses === 1)
-                threads.delete(thread);
+            // 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 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 (read.said.length === 0)
+                await settle(thread);
+            return read;
+        });
+        // 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 there = await listed();
+        if (cut())
+            return undefined;
+        const replyId = crypto.randomUUID();
+        const decided = await main.decide(read.said, there, (text) => out.delta(thread, replyId, text));
+        if (!decided || cut())
+            return undefined;
+        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 {
-            held.uses--;
+            // 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);
         }
-    };
-    const of = (thread) => {
-        const found = threads.get(thread) ?? open(thread);
-        threads.set(thread, found);
-        return found;
+        return work;
     };
     /**
-     * Go on with each turn that was cut off when this store was last used: by a looper closing
-     * under it, or going without closing. Each goes on once, and waits for a place like any turn.
-     * One that can't go on now keeps its mark for the next time. A stopped looper goes on with
-     * none, and its marks go: so does one stopped before it was asked to. Whoever hosts the looper calls this when a request can be made;
-     * once the marks have been read, a later call does nothing.
+     * 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.
      */
-    async function resume() {
-        if (looked || closed)
+    let decided = Promise.resolve();
+    /**
+     * 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 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;
-        looked = true;
-        const keys = [];
-        try {
-            let after;
-            do {
-                const page = await store.list({ prefix: UNFINISHED, ...(after ? { after } : {}) });
-                keys.push(...page.keys);
-                after = page.next ?? undefined;
-            } while (after);
-        }
-        catch (error) {
-            looked = false;
+        if (routes.has(thread))
+            return;
+        const at = cuts;
+        const cut = () => at !== cuts;
+        const routing = decided
+            .then(async () => {
+            if (cut())
+                return;
+            const work = followed.get(thread) ?? (await decide(thread, cut));
+            if (work === undefined)
+                return;
+            // In the thread's line: a message being kept there now is kept first, and goes with them.
+            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())
+                        await wait(thread, false);
+                    return;
+                }
+                leftAtClose(work);
+                await settle(thread);
+            });
+        })
+            .catch(async (error) => {
+            if (closed)
+                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; 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 (unread.has(thread) && !cut() && marks.has(thread))
+                route(thread);
+            tally();
+        });
+        decided = routing;
+        routes.set(thread, routing);
+        tally();
+    };
+    /** 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 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: 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));
+        // Stopped or closed while it was kept, it waits: for the next message, or the next start.
+        if (at === cuts)
+            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 { 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 (marks.has(thread) && !routes.has(thread))
+            await settle(thread);
+        return sent;
+    };
+    /**
+     * Go on with what was cut off when this store was last used, by a looper closing under it or
+     * going without closing: each turn that hadn't ended, once, waiting for a place like any turn;
+     * and each thread whose messages were still to be given to a piece of work, once too. A turn
+     * that can't go on now keeps its mark for the next time. A stopped looper goes on with none:
+     * its turns' marks go, and its waiting messages wait for their thread's next. Whoever hosts the
+     * looper calls this when a request can be made; once the marks have been read, a later call
+     * does nothing. `drop` goes on with nothing, as a stopped looper does.
+     */
+    const goOn = async (drop) => {
+        const at = cuts;
+        /** Whether anything may still go on: not once it has stopped or closed since this began. */
+        const going = () => !drop && !stopped && at === cuts;
+        await learn();
+        const keys = await keysUnder(UNFINISHED);
         for (const key of keys) {
             // Closed meanwhile: what is left stays marked, for whoever opens the store next.
             if (closed)
                 return;
-            const thread = decodeURIComponent(key.slice(UNFINISHED.length));
-            const held = of(thread);
+            const id = decodeURIComponent(key.slice(UNFINISHED.length));
+            const held = of(id);
             try {
-                if (!stopped)
-                    await using(thread, (loop) => loop.resume());
-                // A thread in a turn now keeps the mark as that turn's, and a looper that has closed
-                // leaves it. Otherwise nothing goes on, and it goes.
+                if (going())
+                    await using(id, (loop) => loop.resume());
+                // Work in a turn now keeps the mark as that turn's, and a looper that has closed leaves
+                // it. Otherwise nothing goes on, and it goes.
                 if (!held.marked && !closed)
                     held.mark(false);
             }
@@ -217,65 +639,123 @@ export function createLooper(options) {
                 log.warn("A turn that was cut off didn't go on.", { key, error: String(error) });
             }
         }
-    }
+        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 written apart from a message kept there.
+                await inLine(thread, async () => {
+                    if (routes.has(thread) || marks.get(thread) !== true || closed)
+                        return;
+                    if (going())
+                        route(thread);
+                    await wait(thread, false);
+                });
+            }
+            catch (error) {
+                log.warn("A message that was waiting wasn't placed.", { thread, error: String(error) });
+            }
+        }
+    };
+    /** What was cut off is looked for once; a look that couldn't read the store is made again. */
+    let looked;
+    const resume = (drop = false) => {
+        if (closed)
+            return Promise.resolve();
+        if (!looked) {
+            const look = goOn(drop);
+            looked = look;
+            look.catch(() => {
+                if (looked === look)
+                    looked = undefined;
+            });
+        }
+        return looked;
+    };
     return {
         /**
-         * 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 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.
          */
-        async send(thread, text) {
-            mayStart();
-            const sent = await using(thread, (loop) => loop.send(text));
-            // Recorded as the looper closed, its turn was cut before it began: it is marked like one.
-            const held = threads.get(thread);
-            if (closed && held && !held.marked)
-                held.mark(true);
-            return sent;
+        send(thread, text) {
+            try {
+                mayStart();
+            }
+            catch (error) {
+                return Promise.reject(error);
+            }
+            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) ?? (!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 () => {
+                const work = await workOf(thread);
+                // Stopped or closed while its work was found: nothing of it is kept.
+                mayStart(at);
+                return work === undefined ? intake(thread, text, at) : give(work, thread, text);
+            }));
         },
-        /** Stop a thread's turn now. A call already running finishes, and its result is kept. */
-        cancel: async (thread) => threads.get(thread)?.loop.cancel(),
-        /** What a thread's loop is doing. */
-        state: (thread) => threads.get(thread)?.loop.state() ?? { state: "idle" },
+        /** Stop a piece of work's turn now. A call already running finishes, and its result is kept. */
+        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`. */
-        page: (thread, before, limit) => of(thread).record.page(before, limit),
+        page: (thread, before, limit) => threadOf(thread).page(before, limit),
         /**
-         * 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.
          */
         async stop() {
             stopped = true;
-            const loops = [...threads.values()].map(({ loop }) => loop);
-            await Promise.all(loops.map((loop) => loop.cancel()));
+            cuts++;
+            const loops = [...works.values()].map(({ loop }) => loop);
+            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 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.
-            await resume().catch((error) => log.warn("The turns that were cut off couldn't be looked for.", { error: String(error) }));
+            // Nor does the next start go on with what waits: a thread's next message does.
+            await resume(true)
+                .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. */
         start() {
             stopped = false;
         },
-        resume,
+        resume: () => resume(),
         /**
-         * 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.
          */
         async close() {
             closed = true;
-            await Promise.all([...threads.values()].map(({ loop }) => loop.cancel()));
+            cuts++;
+            await Promise.all([...[...works.values()].map(({ loop }) => loop.cancel()), main.cancel()]);
         },
-        /** 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. */
         async settled() {
-            await Promise.all([...threads.values()].map(({ loop }) => loop.settled()));
-            await Promise.all([...threads.values()].map(({ writes }) => writes));
+            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) {
-            for (const { loop } of threads.values())
+            main.delta(requestId, text);
+            for (const { loop } of works.values())
                 loop.delta(requestId, text);
         },
     };