@agentorg/cli 0.0.7 → 0.0.8

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

@@ -0,0 +1,34 @@
+import type { Log, Model, ToolSpec } from "./types.js";
+/** What the main loop is told. */
+export declare const MAIN_INSTRUCTIONS = "You are the front desk. You do none of the work and you answer nobody: you say whose a message is, by calling `route` once.\n\nYou are given the pieces of work under way, each by its id and title, and what has come in where no work is listening yet.\n\n- Give it to a piece of work under way only when it points at that work explicitly: it names it, quotes it, or refers to what it is doing, and exactly one piece of work fits. Call `route` with that work's id. Its worker will read it with everything it already knows, and answer where it came in. From then on everything said there goes to that work.\n- Anything else is new work, also when it is on a subject like that of work under way. Call `route` with no `work`, and a `title` of a few words that says what the new work is.\n\nA wrong match stays, so when in doubt it is new work. Your only answer is the call.";
+/** The one function the main loop calls. */
+export declare const ROUTE: ToolSpec;
+/** A piece of work as the main loop is told of it. */
+export interface Underway {
+    id: string;
+    title: string;
+}
+/** What the main loop decided: work under way that takes the messages, or new work's title. */
+export type Routed = {
+    work: string;
+} | {
+    title: string;
+};
+/** A work's title: the first line of `text` that says anything, in a few words. */
+export declare const titled: (text: string) => string;
+/** What has come in, as it is put to the main loop with the work under way. */
+export declare const put: (texts: string[], underway: Underway[]) => string;
+export declare function createMain(options: {
+    model: Model;
+    /** Which model to ask, none meaning the model's own default. */
+    chosen(): Promise<string | undefined>;
+    log: Log;
+}): {
+    /**
+     * Say whose `texts` are, given the work under way: one decision at a time. Nothing is said
+     * for a decision that is cancelled. A request the model refuses rejects, as it refused.
+     */
+    route(texts: string[], underway: Underway[]): Promise<Routed | undefined>;
+    /** Drop the decision being made: its request is cancelled, and it says nothing. */
+    cancel(): Promise<void>;
+};

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

@@ -0,0 +1,116 @@
+/**
+ * The main loop: one per looper. It is given the messages that have come in where no piece of
+ * work is listening, and says whose they are: new work, or work under way. It does none of the
+ * work and answers nobody. It has one function to call, and each decision is one model request
+ * that holds nothing of the decisions before it.
+ */
+import { head } from "./record.js";
+/** What the main loop is told. */
+export const MAIN_INSTRUCTIONS = `You are the front desk. You do none of the work and you answer nobody: you say whose a message is, by calling \`route\` once.
+
+You are given the pieces of work under way, each by its id and title, and what has come in where no work is listening yet.
+
+- Give it to a piece of work under way only when it points at that work explicitly: it names it, quotes it, or refers to what it is doing, and exactly one piece of work fits. Call \`route\` with that work's id. Its worker will read it with everything it already knows, and answer where it came in. From then on everything said there goes to that work.
+- Anything else is new work, also when it is on a subject like that of work under way. Call \`route\` with no \`work\`, and a \`title\` of a few words that says what the new work is.
+
+A wrong match stays, so when in doubt it is new work. Your only answer is the call.`;
+/** The one function the main loop calls. */
+export const ROUTE = {
+    name: "route",
+    description: "Says whose what came in is: a piece of work under way, or new work.",
+    parameters: {
+        type: "object",
+        properties: {
+            work: {
+                type: "string",
+                description: "The id of the work under way that it points at. Leave it out for new work.",
+            },
+            title: {
+                type: "string",
+                description: "For new work: a few words that say what it is.",
+            },
+        },
+    },
+};
+/** A work's title: the first line of `text` that says anything, in a few words. */
+export const titled = (text) => head((text.split("\n").find((line) => /\S/.test(line)) ?? "").replace(/\s+/g, " ").trim(), 80);
+/** The main loop is put the newest messages waiting, and the start of each: enough to place them. */
+const PUT = { messages: 8, each: 4000 };
+/** What has come in, as it is put to the main loop with the work under way. */
+export const put = (texts, underway) => [
+    underway.length === 0 ? "No work is under way." : "Work under way:",
+    ...underway.map(({ id, title }) => `- ${id}: ${title}`),
+    "",
+    "What came in:",
+    texts
+        .slice(-PUT.messages)
+        .map((text) => (text.length > PUT.each ? `${head(text, PUT.each)}…` : text))
+        .join("\n\n"),
+].join("\n");
+export function createMain(options) {
+    /** The decision being made now, and how to drop it. */
+    let deciding;
+    return {
+        /**
+         * Say whose `texts` are, given the work under way: one decision at a time. Nothing is said
+         * for a decision that is cancelled. A request the model refuses rejects, as it refused.
+         */
+        async route(texts, underway) {
+            let drop = () => { };
+            const dropped = new Promise((resolve) => {
+                drop = () => resolve(undefined);
+            });
+            const mine = { drop };
+            deciding = mine;
+            try {
+                const chosen = await Promise.race([options.chosen().then((model) => ({ model })), dropped]);
+                if (!chosen)
+                    return undefined;
+                mine.requestId = crypto.randomUUID();
+                const asked = options.model.respond({
+                    requestId: mine.requestId,
+                    ...(chosen.model ? { model: chosen.model } : {}),
+                    instructions: MAIN_INSTRUCTIONS,
+                    input: [{ type: "message", role: "user", content: put(texts, underway) }],
+                    tools: [ROUTE],
+                });
+                // A model that never answers a request it was told to cancel holds nothing up.
+                asked.catch(() => { });
+                const answer = await Promise.race([asked, dropped]);
+                if (!answer)
+                    return undefined;
+                const call = answer.output.find((item) => item.type === "function_call" && item.name === ROUTE.name);
+                let said = {};
+                if (call?.type === "function_call")
+                    try {
+                        said = (JSON.parse(call.arguments) ?? {});
+                    }
+                    catch {
+                        // Arguments that don't read: new work, as with no call.
+                    }
+                if (underway.some(({ id }) => id === said.work))
+                    return { work: said.work };
+                // Anything else starts new work, titled by what came in if the model gave no title.
+                if (typeof said.work === "string" && said.work !== "")
+                    options.log.warn("The main loop named work that isn't under way; it is new work.", {
+                        work: head(said.work, 128),
+                    });
+                const title = titled(typeof said.title === "string" ? said.title : "");
+                return { title: title || titled(texts.join("\n")) };
+            }
+            finally {
+                if (deciding === mine)
+                    deciding = undefined;
+            }
+        },
+        /** Drop the decision being made: its request is cancelled, and it says nothing. */
+        async cancel() {
+            const cut = deciding;
+            if (!cut)
+                return;
+            cut.drop();
+            if (cut.requestId)
+                await options.model.cancel({ requestId: cut.requestId }).catch(() => { });
+        },
+    };
+}

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

@@ -1,7 +1,9 @@
 /**
- * The record a loop runs on, kept in a store: one key per message, holding the items a model reads
- * for it, and for a tool message the line a person sees. It is read once, then kept in memory, and
- * the oldest messages are deleted past a retention cap.
+ * What a loop runs on, kept in a store. A thread keeps its messages, one key each: the items a
+ * model reads for it, and for a tool message the line a person sees. A thread is read once, then
+ * kept in memory, and its oldest messages are deleted past a retention cap. A piece of work reads
+ * its context from the threads it follows: each message is kept once, in the thread where it is
+ * shown, and says which work it belongs to when that isn't its thread's own.
  */
 import { z } from "zod";
 import { Item, type Log, type Shown, type Store } from "./types.js";
@@ -38,6 +40,8 @@ export declare const Entry: z.ZodObject<{
     }>>;
     joined: z.ZodOptional<z.ZodLiteral<true>>;
     ahead: z.ZodOptional<z.ZodNumber>;
+    work: z.ZodOptional<z.ZodString>;
+    place: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 export type Entry = z.output<typeof Entry>;
 /** Where a record's messages are kept in its store. */
@@ -62,38 +66,116 @@ export declare const argumentsOf: (args: string) => string;
 export declare function messageOf(entry: Entry): Shown;
 /** Stored values read at once when what is kept is first loaded. */
 export declare const READS = 16;
-export declare function createRecord(store: Store, log: Log, limits?: {
+/** A user message as it is kept when said. */
+export declare const userEntry: (text: string) => {
+    role: "user";
+    items: {
+        type: "message";
+        role: "user";
+        content: string;
+    }[];
+};
+/** A message as a thread holds it. */
+interface Kept {
+    /** Its number in its thread. */
+    seq: number;
+    key: string;
+    entry: Entry;
+    bytes: number;
+    /** Set while a user message is being written, or taken: the model is sent it once stored. */
+    writing?: boolean;
+}
+interface Held {
+    records: Kept[];
+    last: number;
+    bytes: number;
+}
+/** A thread's messages in a store, by their numbers. */
+export declare function createThread(store: Store, log: Log, limits?: {
     keep: number;
     keepBytes: number;
 }): {
+    /** What it holds, read once. */
+    load: () => Promise<Held>;
     /**
-     * Keep a message, under `id` or its own number, and delete the oldest past the cap. A tool
-     * message the store refuses is still kept in memory, since its call has run. `read` is given
-     * for what came of a model request that had read the record up to that number: when a user
-     * message was said since, it is kept as `ahead` of it.
+     * Keep a message in a thread already read, at once, under `id` or its own number; `stored`
+     * settles when it is written and the oldest past the cap are deleted. A tool message the store
+     * refuses is still kept in memory, since its call has run; any other is taken out again.
      */
-    append(entry: Omit<Entry, "id" | "at">, id?: string, read?: number): Promise<Entry>;
-    /** Whether nothing is kept. */
-    empty(): Promise<boolean>;
+    push(held: Held, entry: Omit<Entry, "id" | "at">, id?: string): {
+        record: Kept;
+        stored: Promise<void>;
+    };
+    /**
+     * Keep a message as `entry` from now on: at once in memory, then in the store. A write the
+     * store refuses leaves it as it was.
+     */
+    rewrite(held: Held, record: Kept, entry: Entry): Promise<void>;
     /** Messages before `before`, oldest first, as many as fit `limit` and `PAGE_BUDGET`. */
     page(before: string | undefined, limit: number): Promise<{
         messages: Shown[];
         more: boolean;
     }>;
+};
+export type Thread = ReturnType<typeof createThread>;
+/**
+ * A piece of work's record: its messages across the threads it follows, in the order it took them.
+ * Its id is the name of its own thread, whose messages are its unless they name another work; in
+ * any other thread, the messages that name it are. A message's place is its number in its own
+ * thread until the work follows a second thread, and a count kept with each message after. A
+ * message waiting in a thread it follows, said before the work had the thread, names no work yet:
+ * the work takes it, in the order it was said, before it keeps anything else there.
+ */
+export declare function createRecord(options: {
+    id: string;
+    /** The threads it follows now, its own first. */
+    follows(): string[];
+    thread(name: string): Thread;
+}): {
+    id: string;
+    /**
+     * Keep a message of its in `thread`, one of those it follows, after any waiting there. `read`
+     * is given for what came of a model request that had read it up to that place: when a user
+     * message was said since, it is kept as `ahead` of it.
+     */
+    append(entry: Omit<Entry, "id" | "at" | "work" | "place" | "ahead">, at: {
+        thread: string;
+        id?: string;
+        read?: number;
+    }): Promise<{
+        entry: Entry;
+        thread: string;
+    }>;
+    /**
+     * Take the messages waiting in `thread`, which it has come to follow, as its own: `joined`,
+     * when a turn of its is running. It says how many there were to answer: in its own thread,
+     * where nothing needs taking, those said since it last did anything.
+     */
+    adopt(thread: string, joined: boolean): Promise<number>;
+    /** Whether it holds anything but what was said to it: it has had a turn that did something. */
+    begun(): Promise<boolean>;
+    /** Whether it has no message. */
+    empty(): Promise<boolean>;
+    /** The thread it answers in now. */
+    where(): Promise<string>;
+    /** Its first user message, for a title. */
+    opening(): Promise<string>;
     /**
      * The conversation to send: the newest exchanges (each from the user message that starts a turn
      * on) that fit the budget, and always the latest two, so "go on" after a long turn still has
      * that turn. When those two are over the budget, their oldest function arguments and outputs
      * are left out, each call still paired with an output. A message said during a turn comes after
-     * whatever is `ahead` of it, so the model reads it as not yet answered. `read` is the number
-     * up to which every user message was read, for `append` and `saidAfter`: one still being
-     * written is not read yet.
+     * whatever is `ahead` of it, so the model reads it as not yet answered. `read` is the place up
+     * to which every user message was read, for `append` and `saidAfter`: one still being written
+     * is not read yet. `thread` is where what comes of it is kept.
      */
     input(): Promise<{
         items: Item[];
         read: number;
+        thread: string;
     }>;
-    /** Whether a user message has been stored after the one numbered `read`, which `input` gave. */
+    /** Whether a user message of its has been stored after the place `read`, which `input` gave. */
     saidAfter(read: number): Promise<boolean>;
 };
 export type LoopRecord = ReturnType<typeof createRecord>;
+export {};

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

@@ -1,7 +1,9 @@
 /**
- * The record a loop runs on, kept in a store: one key per message, holding the items a model reads
- * for it, and for a tool message the line a person sees. It is read once, then kept in memory, and
- * the oldest messages are deleted past a retention cap.
+ * What a loop runs on, kept in a store. A thread keeps its messages, one key each: the items a
+ * model reads for it, and for a tool message the line a person sees. A thread is read once, then
+ * kept in memory, and its oldest messages are deleted past a retention cap. A piece of work reads
+ * its context from the threads it follows: each message is kept once, in the thread where it is
+ * shown, and says which work it belongs to when that isn't its thread's own.
  */
 import { z } from "zod";
 import { Item } from "./types.js";
@@ -18,11 +20,17 @@ export const Entry = z.object({
     /** For a user message said while a turn was running: it is part of that turn. */
     joined: z.literal(true).optional(),
     /**
-     * For what came of a model request that had read the record up to the message of this number,
-     * when a user message was said after that: the model reads it ahead of that message, which it
-     * doesn't answer.
+     * For what came of a model request that had read its work up to this place, when a user message
+     * was said after that: the model reads it ahead of that message, which it doesn't answer.
      */
     ahead: z.number().optional(),
+    /** The piece of work it belongs to, when that isn't its thread's own. */
+    work: z.string().optional(),
+    /**
+     * Its place in its work's order, once that work follows more than one thread. Without it, its
+     * place is its number in its thread.
+     */
+    place: z.number().optional(),
 });
 /** Where a record's messages are kept in its store. */
 export const MESSAGES = "msg/";
@@ -96,9 +104,13 @@ const kept = (entry) => ({
 });
 /** Stored values read at once when what is kept is first loaded. */
 export const READS = 16;
-/** Whether a user message follows the one numbered `read`: one `stored` already, when asked so. */
-const saidAfter = (records, read, stored = false) => records.some((record) => record.entry.role === "user" && seqOf(record.key) > read && !(stored && record.writing));
-export function createRecord(store, log, limits = { keep: KEEP, keepBytes: KEEP_BYTES }) {
+/** A user message as it is kept when said. */
+export const userEntry = (text) => ({
+    role: "user",
+    items: [{ type: "message", role: "user", content: text }],
+});
+/** A thread's messages in a store, by their numbers. */
+export function createThread(store, log, limits = { keep: KEEP, keepBytes: KEEP_BYTES }) {
     let loaded;
     const load = () => {
         if (loaded)
@@ -126,7 +138,7 @@ export function createRecord(store, log, limits = { keep: KEEP, keepBytes: KEEP_
                             log.warn("A stored message didn't read back; it is left out.", { key });
                             return;
                         }
-                        const record = { key, entry: parsed.data, bytes: size(parsed.data) };
+                        const record = { seq: seqOf(key), key, entry: parsed.data, bytes: size(parsed.data) };
                         records.push(record);
                         bytes += record.bytes;
                     });
@@ -143,57 +155,75 @@ export function createRecord(store, log, limits = { keep: KEEP, keepBytes: KEEP_
         return attempt;
     };
     return {
+        /** What it holds, read once. */
+        load,
         /**
-         * Keep a message, under `id` or its own number, and delete the oldest past the cap. A tool
-         * message the store refuses is still kept in memory, since its call has run. `read` is given
-         * for what came of a model request that had read the record up to that number: when a user
-         * message was said since, it is kept as `ahead` of it.
+         * Keep a message in a thread already read, at once, under `id` or its own number; `stored`
+         * settles when it is written and the oldest past the cap are deleted. A tool message the store
+         * refuses is still kept in memory, since its call has run; any other is taken out again.
          */
-        async append(entry, id, read) {
-            const state = await load();
-            const key = keyOf(++state.last);
+        push(held, entry, id) {
+            const seq = ++held.last;
+            const key = keyOf(seq);
             const record = {
+                seq,
                 key,
                 entry: kept({
                     id: id ?? key.slice(MESSAGES.length),
                     at: new Date().toISOString(),
                     ...entry,
-                    ...(read !== undefined && saidAfter(state.records, read) ? { ahead: read } : {}),
                 }),
                 bytes: 0,
                 writing: entry.role === "user",
             };
             record.bytes = size(record.entry);
-            state.records.push(record);
-            state.bytes += record.bytes;
+            held.records.push(record);
+            held.bytes += record.bytes;
+            const stored = (async () => {
+                try {
+                    await store.set({ key, value: record.entry });
+                    record.writing = false;
+                }
+                catch (error) {
+                    if (entry.role !== "tool") {
+                        held.records.splice(held.records.indexOf(record), 1);
+                        held.bytes -= record.bytes;
+                        throw error;
+                    }
+                    log.error("A tool message couldn't be stored; it is kept until a restart.", {
+                        error: String(error),
+                    });
+                }
+                while (held.records.length > 1 &&
+                    (held.records.length > limits.keep || held.bytes > limits.keepBytes)) {
+                    const oldest = held.records.shift();
+                    held.bytes -= oldest.bytes;
+                    await store.delete({ key: oldest.key }).catch((error) => log.warn("An old message couldn't be deleted.", {
+                        key: oldest.key,
+                        error: String(error),
+                    }));
+                }
+            })();
+            return { record, stored };
+        },
+        /**
+         * Keep a message as `entry` from now on: at once in memory, then in the store. A write the
+         * store refuses leaves it as it was.
+         */
+        async rewrite(held, record, entry) {
+            const was = { entry: record.entry, bytes: record.bytes };
+            const swap = (to) => {
+                held.bytes += to.bytes - record.bytes;
+                Object.assign(record, to);
+            };
+            swap({ entry, bytes: size(entry) });
             try {
-                await store.set({ key, value: record.entry });
-                record.writing = false;
+                await store.set({ key: record.key, value: entry });
             }
             catch (error) {
-                if (entry.role !== "tool") {
-                    state.records.splice(state.records.indexOf(record), 1);
-                    state.bytes -= record.bytes;
-                    throw error;
-                }
-                log.error("A tool message couldn't be stored; it is kept until a restart.", {
-                    error: String(error),
-                });
+                swap(was);
+                throw error;
             }
-            while (state.records.length > 1 &&
-                (state.records.length > limits.keep || state.bytes > limits.keepBytes)) {
-                const oldest = state.records.shift();
-                state.bytes -= oldest.bytes;
-                await store.delete({ key: oldest.key }).catch((error) => log.warn("An old message couldn't be deleted.", {
-                    key: oldest.key,
-                    error: String(error),
-                }));
-            }
-            return record.entry;
-        },
-        /** Whether nothing is kept. */
-        async empty() {
-            return (await load()).records.length === 0;
         },
         /** Messages before `before`, oldest first, as many as fit `limit` and `PAGE_BUDGET`. */
         async page(before, limit) {
@@ -215,19 +245,144 @@ export function createRecord(store, log, limits = { keep: KEEP, keepBytes: KEEP_
             }
             return { messages, more: start > 0 };
         },
+    };
+}
+/**
+ * A piece of work's record: its messages across the threads it follows, in the order it took them.
+ * Its id is the name of its own thread, whose messages are its unless they name another work; in
+ * any other thread, the messages that name it are. A message's place is its number in its own
+ * thread until the work follows a second thread, and a count kept with each message after. A
+ * message waiting in a thread it follows, said before the work had the thread, names no work yet:
+ * the work takes it, in the order it was said, before it keeps anything else there.
+ */
+export function createRecord(options) {
+    const { id } = options;
+    const placeOf = (record) => record.entry.place ?? record.seq;
+    const mine = (thread, record) => record.entry.work === undefined ? thread === id : record.entry.work === id;
+    /** Every thread it follows, read: what each holds, as it changes. */
+    const load = async () => {
+        const held = new Map();
+        for (const name of options.follows())
+            held.set(name, await options.thread(name).load());
+        return held;
+    };
+    /**
+     * Its own messages in the threads read, in order, as they stand now. Nothing waits between
+     * this and what is decided from it.
+     */
+    const own = (held) => {
+        const records = [...held].flatMap(([thread, { records }]) => records.flatMap((record) => (mine(thread, record) ? [{ thread, record }] : [])));
+        // One thread's messages are in order already.
+        if (held.size > 1)
+            records.sort((a, b) => placeOf(a.record) - placeOf(b.record));
+        return records;
+    };
+    /** The highest place among its messages. */
+    const topOf = (records) => {
+        const last = records.at(-1);
+        return last ? placeOf(last.record) : 0;
+    };
+    /**
+     * Take the messages waiting in `thread` as its own, after all it holds: at once in memory, and
+     * `written` settles when each is stored, or rejects with one that isn't and stays waiting. Like
+     * a message being written, the model is sent none of them until all are stored.
+     */
+    const take = (held, thread, joined) => {
+        const from = held.get(thread);
+        const waiting = thread === id ? [] : from.records.filter(({ entry }) => !entry.work);
+        let top = topOf(own(held));
+        const writes = waiting.map((record) => options.thread(thread).rewrite(from, record, {
+            ...record.entry,
+            work: id,
+            place: ++top,
+            ...(joined && record.entry.role === "user" ? { joined: true } : {}),
+        }));
+        for (const record of waiting)
+            record.writing = true;
+        const written = Promise.allSettled(writes).then((all) => {
+            for (const record of waiting)
+                record.writing = false;
+            const refused = all.find((one) => one.status === "rejected");
+            if (refused)
+                throw refused.reason;
+        });
+        return { taken: waiting.length, written };
+    };
+    /** Whether a user message of its follows the place `read`: one `stored` already, when asked. */
+    const saidAfter = (records, read, stored = false) => records.some(({ record }) => record.entry.role === "user" && placeOf(record) > read && !(stored && record.writing));
+    /** The thread of its newest user message: where it answers. Its own, with none. */
+    const whereOf = (records) => records.findLast(({ record }) => record.entry.role === "user")?.thread ?? id;
+    return {
+        id,
+        /**
+         * Keep a message of its in `thread`, one of those it follows, after any waiting there. `read`
+         * is given for what came of a model request that had read it up to that place: when a user
+         * message was said since, it is kept as `ahead` of it.
+         */
+        async append(entry, at) {
+            const held = await load();
+            const { thread } = at;
+            // What waits there is taken and stored first, so this is never kept ahead of it: it joins
+            // a turn if this does, or comes of one. If the store won't take it, nothing is kept.
+            await take(held, thread, entry.joined === true || at.read !== undefined).written;
+            // From here to the push nothing waits, so its place and what is ahead of it are decided
+            // with the record as it stands.
+            const records = own(held);
+            const { record, stored } = options.thread(thread).push(held.get(thread), {
+                ...entry,
+                ...(thread === id ? {} : { work: id }),
+                ...(held.size > 1 ? { place: topOf(records) + 1 } : {}),
+                ...(at.read !== undefined && saidAfter(records, at.read) ? { ahead: at.read } : {}),
+            }, at.id);
+            await stored;
+            return { entry: record.entry, thread };
+        },
+        /**
+         * Take the messages waiting in `thread`, which it has come to follow, as its own: `joined`,
+         * when a turn of its is running. It says how many there were to answer: in its own thread,
+         * where nothing needs taking, those said since it last did anything.
+         */
+        async adopt(thread, joined) {
+            const held = await load();
+            const { taken, written } = take(held, thread, joined);
+            await written;
+            if (thread !== id)
+                return taken;
+            const records = own(held);
+            const done = records.findLastIndex(({ record }) => record.entry.role !== "user");
+            return records.length - 1 - done;
+        },
+        /** Whether it holds anything but what was said to it: it has had a turn that did something. */
+        async begun() {
+            return own(await load()).some(({ record }) => record.entry.role !== "user");
+        },
+        /** Whether it has no message. */
+        async empty() {
+            return own(await load()).length === 0;
+        },
+        /** The thread it answers in now. */
+        async where() {
+            return whereOf(own(await load()));
+        },
+        /** Its first user message, for a title. */
+        async opening() {
+            const first = own(await load()).find(({ record }) => record.entry.role === "user");
+            return first ? textOf(first.record.entry) : "";
+        },
         /**
          * The conversation to send: the newest exchanges (each from the user message that starts a turn
          * on) that fit the budget, and always the latest two, so "go on" after a long turn still has
          * that turn. When those two are over the budget, their oldest function arguments and outputs
          * are left out, each call still paired with an output. A message said during a turn comes after
-         * whatever is `ahead` of it, so the model reads it as not yet answered. `read` is the number
-         * up to which every user message was read, for `append` and `saidAfter`: one still being
-         * written is not read yet.
+         * whatever is `ahead` of it, so the model reads it as not yet answered. `read` is the place up
+         * to which every user message was read, for `append` and `saidAfter`: one still being written
+         * is not read yet. `thread` is where what comes of it is kept.
          */
         async input() {
-            const { records, last } = await load();
-            const unwritten = records.find((record) => record.writing);
-            const read = unwritten ? seqOf(unwritten.key) - 1 : last;
+            const records = own(await load());
+            const last = topOf(records);
+            const unwritten = records.find(({ record }) => record.writing);
+            const read = unwritten ? placeOf(unwritten.record) - 1 : last;
             const exchanges = [];
             /** Said during a turn, and not yet put: what is ahead of them goes first. */
             const late = [];
@@ -236,12 +391,12 @@ export function createRecord(store, log, limits = { keep: KEEP, keepBytes: KEEP_
                     exchanges.push([]);
                 exchanges.at(-1)?.push(...entry.items);
             };
-            /** Put the late messages numbered up to `read`. */
+            /** Put the late messages placed up to `read`. */
             const putLate = (read) => {
-                while (late[0] && seqOf(late[0].key) <= read)
+                while (late[0] && placeOf(late[0]) <= read)
                     put(late.shift().entry);
             };
-            for (const record of records) {
+            for (const { record } of records) {
                 // Nothing to send: a user message still being written, or a line with no items.
                 if (record.writing || record.entry.items.length === 0)
                     continue;
@@ -268,11 +423,11 @@ export function createRecord(store, log, limits = { keep: KEEP, keepBytes: KEEP_
                     items[i] = { ...item, arguments: ARGUMENTS_LEFT_OUT };
                 }
             }
-            return { items, read };
+            return { items, read, thread: whereOf(records.filter(({ record }) => !record.writing)) };
         },
-        /** Whether a user message has been stored after the one numbered `read`, which `input` gave. */
+        /** Whether a user message of its has been stored after the place `read`, which `input` gave. */
         async saidAfter(read) {
-            return saidAfter((await load()).records, read, true);
+            return saidAfter(own(await load()), read, true);
         },
     };
 }