@agentorg/cli 0.0.5 → 0.0.7

package/dist/node_modules/@agentorg/shell/package.json

@@ -2,35 +2,48 @@
   "name": "@agentorg/shell",
   "version": "0.0.0",
   "private": true,
-  "description": "The person's web shell for AgentOrg: their agents, their views and their settings.",
+  "description": "The person's web shell for AgentOrg: their agents, what each is made of, and their settings.",
   "license": "MIT",
   "type": "module",
   "engines": {
     "node": ">=22.15"
   },
   "exports": {
-    "./package.json": "./package.json",
-    "./agent-bindings": {
-      "types": "./src/agent-bindings.ts",
-      "default": "./dist/agent-bindings.js"
-    }
+    "./package.json": "./package.json"
   },
   "files": [
-    "dist",
-    "src/agent-bindings.ts"
+    "dist"
   ],
   "scripts": {
-    "build": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\" && tsc -p tsconfig.json && node scripts/build.js"
+    "build": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\" && tsc -p tsconfig.json && tsc -p tsconfig.test.json && node scripts/build.js",
+    "test": "node --experimental-strip-types --no-warnings --test --test-concurrency=3 --test-timeout=60000 \"test/**/*.test.ts\""
   },
   "devDependencies": {
     "@agentorg/interfaces": "0.0.0",
-    "@agentorg/kit": "0.0.0",
     "@agentorg/sdk": "0.0.0",
+    "@playwright/test": "1.64.1",
+    "@shadcn/react": "0.3.1",
+    "@tailwindcss/cli": "4.3.5",
     "@types/react": "19.3.0",
     "@types/react-dom": "19.3.0",
+    "@types/ws": "8.18.2",
+    "@xterm/addon-fit": "0.10.0",
+    "@xterm/xterm": "5.5.0",
+    "class-variance-authority": "0.7.1",
+    "clsx": "2.1.1",
     "esbuild": "0.28.2",
+    "lucide-react": "1.70.0",
+    "radix-ui": "1.8.1",
     "react": "19.3.1",
     "react-dom": "19.3.1",
+    "streamdown": "2.7.1",
+    "tailwind-merge": "3.7.0",
+    "tailwindcss": "4.3.5",
+    "tw-animate-css": "1.4.0",
+    "ws": "8.22.1",
     "zod": "^4.6.7"
+  },
+  "dependencies": {
+    "react-diff-view": "3.3.3"
   }
 }

package/dist/node_modules/@agentorg/wire/dist/src/frames.d.ts

@@ -1,4 +1,4 @@
-/** The largest JSON frame: 1 MiB. `stream` and `http` bodies are raw bytes, not frames. */
+/** The largest JSON frame: 1 MiB. */
 export declare const MAX_FRAME: number;
 export declare class FrameError extends Error {
     readonly name = "FrameError";
@@ -6,8 +6,7 @@ export declare class FrameError extends Error {
 /** A frame: a 4-byte big-endian length, then that many bytes of UTF-8 JSON. */
 export declare function encodeFrame(value: unknown): Uint8Array;
 /**
- * Reads frames from a byte stream, then hands over what follows them untouched: a stream starts
- * with a header frame, and for `open` and `http` the rest is raw bytes.
+ * Reads frames from a byte stream, and can hand over what follows them untouched.
  */
 export declare class FrameReader {
     #private;

package/dist/node_modules/@agentorg/wire/dist/src/frames.js

@@ -1,5 +1,5 @@
 import { ByteQueue } from "./bytes.js";
-/** The largest JSON frame: 1 MiB. `stream` and `http` bodies are raw bytes, not frames. */
+/** The largest JSON frame: 1 MiB. */
 export const MAX_FRAME = 1024 * 1024;
 export class FrameError extends Error {
     name = "FrameError";
@@ -16,8 +16,7 @@ export function encodeFrame(value) {
     return frame;
 }
 /**
- * Reads frames from a byte stream, then hands over what follows them untouched: a stream starts
- * with a header frame, and for `open` and `http` the rest is raw bytes.
+ * Reads frames from a byte stream, and can hand over what follows them untouched.
  */
 export class FrameReader {
     #reader;

package/dist/node_modules/@agentorg/wire/dist/src/ops.d.ts

@@ -7,9 +7,7 @@
  *   closes the channel too. Without `declares` the Actor keeps what it declared before; with it,
  *   `declares` replaces that. The result is `{actorId, bound}`: the Actor's slots bound now. A
  *   newer channel for an Actor replaces its older one; with `replace: false` the hello is refused
- *   instead (`Refused`, code `connected`) while the Actor has a live channel. On a pipe the Hub
- *   made for a package Actor's process, the hello names that Actor and carries no credential (the
- *   pipe is the proof) and no `declares` (a package declares through its manifest).
+ *   instead (`Refused`, code `connected`) while the Actor has a live channel.
  * - `slot`: from the Hub, one of the Actor's slots was bound or unbound after its channel's hello
  *   result was taken. The header is the whole message: the Hub closes its side, and the Actor
  *   closes its side once it has read it (an open notice counts against its streams). Applied in
@@ -17,22 +15,16 @@
  *   they give each slot's state. A `bound: true` for a slot already bound means its provider came
  *   back after going away: the slot is usable again, and what was subscribed must be again. A
  *   provider going away sends nothing; calls meanwhile are `NotConnected`.
- * - `offer` and `withdraw`: the channel's own Actor offers an export at run time, or withdraws
- *   one it offered; one body (`{result: {}}` or `{error}`) answers, then the stream closes.
  * - `call`: the caller sends one `{input}` body and closes its side; the answer is one `{result}`
  *   or `{error}` body, then the stream closes.
  * - `subscribe`: `{event}` bodies flow until the subscriber resets the stream, or the provider
  *   side closes it (with an `{error}` body first when it was refused).
- * - `open` and `http`: the answering side sends exactly one body first, `{result: {}}` to accept
- *   or `{error}` to refuse; after an accept, raw bytes flow both ways, each side closing its own
- *   direction, and a reset ends both. The provider answers the Hub, and the Hub forwards that
- *   answer. The opener may send bytes before the answer; they wait.
  * Cancelling a reader of a yamux stream resets it.
  */
 export type Header = 
 /**
- * Admits a channel; its first stream. An external client's carries its credential and may
- * declare (the Hub validates `declares`); a pipe's names its Actor only.
+ * Admits a channel; its first stream. It carries the Actor's credential and may declare (the
+ * Hub validates `declares`).
  */
 {
     op: "hello";
@@ -49,26 +41,6 @@ export type Header =
     slot: string;
     event: string;
 }
-/** Raw bytes in the interface's protocol, after the Hub validates `params`. */
- | {
-    op: "open";
-    slot: string;
-    params: unknown;
-}
-/** HTTP/1.1 bytes. */
- | {
-    op: "http";
-    slot: string;
-}
-/** Offer an export at run time, as a described interface; it lasts until withdrawn or disconnect. */
- | {
-    op: "offer";
-    name: string;
-    interface: unknown;
-} | {
-    op: "withdraw";
-    name: string;
-}
 /**
  * From the Hub to an Actor: one of its slots was bound or unbound. A slot made at run time (an
  * export exposed to this Actor) carries `exposed` while bound: the export's described interface
@@ -81,18 +53,17 @@ export type Header =
     exposed?: Exposure;
 }
 /**
- * From the Hub to a provider: the same four, naming its export, who is calling, and through which
+ * From the Hub to a provider: the same two, naming its export, who is calling, and through which
  * of the caller's slots (a provider keeping state per consumer keys it by both).
  */
  | {
     op: "serve";
-    kind: "call" | "subscribe" | "open" | "http";
+    kind: "call" | "subscribe";
     export: string;
     caller: string;
     slot: string;
     method?: string;
     event?: string;
-    params?: unknown;
 };
 /** A slot made at run time, as the Hub describes it: the export's interface, and whose it is. */
 export interface Exposure {

package/dist/node_modules/@agentorg/wire/dist/src/ops.js

@@ -25,18 +25,6 @@ export function parseHeader(value) {
             return { op: "call", slot: text(value, "slot"), method: text(value, "method") };
         case "subscribe":
             return { op: "subscribe", slot: text(value, "slot"), event: text(value, "event") };
-        case "open":
-            if (!("params" in value))
-                throw new HeaderError("An open header needs params.");
-            return { op: "open", slot: text(value, "slot"), params: value.params };
-        case "http":
-            return { op: "http", slot: text(value, "slot") };
-        case "offer":
-            if (!isRecord(value.interface))
-                throw new HeaderError("An offer header needs an interface.");
-            return { op: "offer", name: text(value, "name"), interface: value.interface };
-        case "withdraw":
-            return { op: "withdraw", name: text(value, "name") };
         case "slot": {
             if (typeof value.bound !== "boolean")
                 throw new HeaderError("A slot header needs bound.");
@@ -63,10 +51,8 @@ export function parseHeader(value) {
         }
         case "serve": {
             const kind = value.kind;
-            if (kind !== "call" && kind !== "subscribe" && kind !== "open" && kind !== "http")
-                throw new HeaderError("A serve header's kind must be call, subscribe, open or http.");
-            if (kind === "open" && !("params" in value))
-                throw new HeaderError("An open serve header needs params.");
+            if (kind !== "call" && kind !== "subscribe")
+                throw new HeaderError("A serve header's kind must be call or subscribe.");
             return {
                 op: "serve",
                 kind,
@@ -75,7 +61,6 @@ export function parseHeader(value) {
                 slot: text(value, "slot"),
                 ...(kind === "call" ? { method: text(value, "method") } : {}),
                 ...(kind === "subscribe" ? { event: text(value, "event") } : {}),
-                ...(kind === "open" ? { params: value.params } : {}),
             };
         }
         default:

package/dist/node_modules/assistant/dist/src/chats.d.ts

@@ -0,0 +1,92 @@
+/**
+ * An agent's chats: each one's entry in the store, and the looper's thread it is. A chat is made by
+ * the message that starts it and is never deleted. The entries are read when a chat is first asked
+ * for, all of them, and then stay in memory.
+ */
+import { type ChatEntry, type chat, type kv } from "@agentorg/interfaces";
+import { type Model, type Tool } from "@agentorg/looper";
+import { type Log, type Slot } from "@agentorg/sdk";
+import { z } from "zod";
+type Store = Slot<typeof kv>["call"];
+type Listed = z.input<typeof ChatEntry>;
+type Input<M extends keyof (typeof chat)["methods"]> = z.output<(typeof chat)["methods"][M]["input"]>;
+type Emitted<E extends keyof (typeof chat)["events"]> = z.input<(typeof chat)["events"][E]["payload"]>;
+export declare function createChats(options: {
+    store: Store;
+    /** The agent's model, and what a request to it says and offers, as its looper asks for them. */
+    model: Model;
+    request(): Promise<{
+        instructions: string;
+        tools: Tool[];
+        model?: string | undefined;
+    }>;
+    /** Whether the agent is stopped when its chats are first held. */
+    stopped: boolean;
+    emit: {
+        message(message: Emitted<"message">): void;
+        delta(delta: Emitted<"delta">): void;
+        status(status: Emitted<"status">): void;
+        chat(entry: Listed): void;
+    };
+    log: Log;
+}): {
+    /**
+     * Say a message in a chat, or in a new chat it starts. With no turn in the chat it starts one;
+     * a turn running there takes it at its next model request.
+     */
+    send({ chat, text }: Input<"send">): Promise<{
+        chat: string;
+        messageId: string;
+    }>;
+    history: ({ chat, before, limit }: Input<"history">) => Promise<{
+        messages: import("@agentorg/looper").Shown[];
+        more: boolean;
+    }>;
+    /** What the agent is doing now. */
+    state: () => {
+        state: "idle" | "working";
+    };
+    /**
+     * The chats after `before` in the list, the one a message was last sent in first. `before`
+     * holds its place whether it is archived or not, so a page never leaves out a chat that hasn't
+     * moved since the page before it.
+     */
+    list({ archived, before, limit }: Input<"list">): Promise<{
+        chats: {
+            id: string;
+            title: string;
+            at: string;
+            latest?: {
+                id: string;
+                at: string;
+            } | undefined;
+            problem?: {
+                code: string;
+                message: string;
+            } | undefined;
+            archived: boolean;
+        }[];
+        more: boolean;
+    }>;
+    rename({ chat, title }: Input<"rename">): Promise<{}>;
+    archive({ chat, archived }: Input<"archive">): Promise<{}>;
+    /**
+     * Stop the agent: its turns are cut, and none starts until it is started. A call already
+     * running finishes first, so this answers when nothing more will be written. Its chats stay as
+     * they are, to be read.
+     */
+    stop: () => Promise<void>;
+    start: () => void;
+    /** Go on with the turns that were cut off when the agent last ran, each once. */
+    resume(): Promise<void>;
+    /**
+     * Close for good: its turns are cut, and none starts after. They stay marked, so the engine
+     * that opens this store next goes on with them.
+     */
+    close: () => Promise<void>;
+    /** Settles when every chat's latest turn has written all it will. */
+    settled(): Promise<void>;
+    /** Streamed text of the model request running now. */
+    delta(requestId: string, text: string): void;
+};
+export {};

package/dist/node_modules/assistant/dist/src/chats.js

@@ -0,0 +1,357 @@
+/**
+ * An agent's chats: each one's entry in the store, and the looper's thread it is. A chat is made by
+ * the message that starts it and is never deleted. The entries are read when a chat is first asked
+ * for, all of them, and then stay in memory.
+ */
+import { CHAT_TITLE_MAX, } from "@agentorg/interfaces";
+import { createLooper, Entry, Refusal, textOf, } from "@agentorg/looper";
+import { Refused } from "@agentorg/sdk";
+import { z } from "zod";
+import { head, relayed } from "./tools.js";
+/** A chat's entry is kept under `chats/<id>`. */
+const ENTRIES = "chats/";
+/**
+ * The looper's keys in the agent's store. A chat is a thread by its id, and a thread's record is
+ * where a chat's has always been, under `chat/<id>/`; anything else the looper keeps is under
+ * `loop/`. A list is of one or of the other, never across both. What the store refuses, the looper
+ * is told as its own refusal.
+ */
+const THREADS = "thread/";
+const CHATS = "chat/";
+const REST = "loop/";
+const toStore = (key) => key.startsWith(THREADS) ? CHATS + key.slice(THREADS.length) : REST + key;
+const fromStore = (key) => key.startsWith(CHATS) ? THREADS + key.slice(CHATS.length) : key.slice(REST.length);
+function forLooper(store) {
+    return {
+        get: ({ key }) => relayed(store.get({ key: toStore(key) })),
+        set: ({ key, value }) => relayed(store.set({ key: toStore(key), value })),
+        delete: ({ key }) => relayed(store.delete({ key: toStore(key) })),
+        async list({ prefix = "", after, limit }) {
+            const page = await relayed(store.list({
+                prefix: toStore(prefix),
+                ...(after === undefined ? {} : { after: toStore(after) }),
+                ...(limit === undefined ? {} : { limit }),
+            }));
+            return {
+                keys: page.keys.map(fromStore),
+                next: page.next === null ? null : fromStore(page.next),
+            };
+        },
+    };
+}
+/**
+ * The looper as the chats call it: every call into it passes here. What the looper refuses is
+ * refused as the chat's, and what the store refused comes back as the store's own error.
+ */
+function forChats(looper) {
+    const outward = (error) => {
+        if (!(error instanceof Refusal))
+            throw error;
+        throw error.cause ?? new Refused(error.code, error.message);
+    };
+    return new Proxy(looper, {
+        get(target, name, receiver) {
+            const member = Reflect.get(target, name, receiver);
+            if (typeof member !== "function")
+                return member;
+            return (...given) => {
+                try {
+                    const result = member.apply(target, given);
+                    return result instanceof Promise ? result.catch(outward) : result;
+                }
+                catch (error) {
+                    return outward(error);
+                }
+            };
+        },
+    });
+}
+/** Where the one conversation an agent had before it had chats was kept. */
+const LEGACY = "msg/";
+/** Stored values read at once when the entries, or that conversation, are first loaded. */
+const READS = 16;
+/** The chat that the one conversation an agent had before it had chats becomes. */
+const FIRST = "first";
+const PAGE = 50;
+/** What is kept of a chat beside its record. */
+const Stored = z.object({
+    title: z.string(),
+    at: z.string(),
+    /** Its place in the list: the highest is the chat a message was last sent in. */
+    order: z.number(),
+    latest: z.object({ id: z.string(), at: z.string() }).optional(),
+    /** Why a message in it got no answer, until its next reply. */
+    problem: z.object({ code: z.string(), message: z.string() }).optional(),
+    archived: z.boolean(),
+});
+/** A title from a message: its first line with anything in it, on one line. */
+const titleOf = (text) => head((text.split("\n").find((line) => /\S/.test(line)) ?? "").replace(/\s+/g, " ").trim(), CHAT_TITLE_MAX);
+/** Every key under `prefix`, in order. */
+async function keysUnder(store, prefix) {
+    const keys = [];
+    let after;
+    do {
+        const page = await store.list({ prefix, limit: 1000, ...(after ? { after } : {}) });
+        keys.push(...page.keys);
+        after = page.next ?? undefined;
+    } while (after);
+    return keys;
+}
+export function createChats(options) {
+    const { store, emit, log } = options;
+    /** The highest place in the list given so far. */
+    let top = 0;
+    /** Entries being written, one after another, so the latest written is the latest said. */
+    let writing = Promise.resolve();
+    /** The chats, by id, once their entries are read. */
+    const chats = new Map();
+    let loaded;
+    /** The chats whose loops are at work now: the agent is working while there is one. */
+    const atWork = new Set();
+    const stateNow = () => ({ state: atWork.size > 0 ? "working" : "idle" });
+    /** The chats' loops: a chat is the looper's thread of the same name. */
+    const looper = forChats(createLooper({
+        store: forLooper(store),
+        model: options.model,
+        request: options.request,
+        out: {
+            message(thread, message) {
+                const held = chats.get(thread);
+                if (held)
+                    sent(held, message);
+                emit.message({ ...message, chat: thread });
+            },
+            delta: (thread, id, text) => emit.delta({ chat: thread, id, text }),
+            status(thread, status) {
+                const was = atWork.size > 0;
+                if (status.state === "thinking" || status.state === "tool")
+                    atWork.add(thread);
+                else
+                    atWork.delete(thread);
+                // A turn that failed left its chat's message with no answer: the chat is told why,
+                // before the agent is said to be idle.
+                const held = chats.get(thread);
+                if (status.state === "error" && held) {
+                    const { code, message } = status.detail;
+                    held.stored.problem = { code: head(code, 128), message: head(message, 2000) };
+                    told(held);
+                }
+                if (atWork.size > 0 !== was)
+                    emit.status(stateNow());
+            },
+        },
+        stopped: options.stopped,
+        log,
+    }));
+    const entryOf = ({ id, stored }) => ({
+        id,
+        title: stored.title,
+        at: stored.at,
+        ...(stored.latest ? { latest: stored.latest } : {}),
+        ...(stored.problem ? { problem: stored.problem } : {}),
+        archived: stored.archived,
+    });
+    /** Write a chat's entry as it now is, after any write before it. */
+    const save = (held) => {
+        const value = { ...held.stored };
+        const written = writing.then(() => store.set({ key: ENTRIES + held.id, value }));
+        writing = written.catch(() => { });
+        return written;
+    };
+    /** Say a chat's entry as it now is; its write follows. */
+    const told = (held) => {
+        // What it tells is already so: an entry that can't be written is behind until the next.
+        save(held).catch((error) => log.error("A chat's entry couldn't be stored.", { chat: held.id, error: String(error) }));
+        emit.chat(entryOf(held));
+    };
+    /**
+     * A message sent in a chat moves it to the front of the list; a reply is what is new in it, and
+     * its message has its answer.
+     */
+    const sent = (held, message) => {
+        if (message.role === "tool")
+            return;
+        held.stored.order = ++top;
+        if (message.role === "assistant") {
+            held.stored.latest = { id: message.id, at: message.at };
+            delete held.stored.problem;
+        }
+        told(held);
+    };
+    /** Change what a chat is called or where it is listed: a change the store refuses isn't made. */
+    const keep = async (held, key, value) => {
+        const was = held.stored[key];
+        held.stored[key] = value;
+        try {
+            await save(held);
+        }
+        catch (error) {
+            held.stored[key] = was;
+            throw error;
+        }
+        emit.chat(entryOf(held));
+    };
+    /**
+     * The conversation an agent had before it had chats becomes its first chat. Its entry is written
+     * before any message moves, from all of them, so a move cut short goes on from where it stopped
+     * with the entry it began with.
+     */
+    const adopt = async () => {
+        const keys = await keysUnder(store, LEGACY);
+        if (keys.length === 0)
+            return;
+        const values = [];
+        for (let at = 0; at < keys.length; at += READS)
+            values.push(...(await Promise.all(keys.slice(at, at + READS).map((key) => store.get({ key })))).map((read) => read.value));
+        if (!Stored.safeParse((await store.get({ key: ENTRIES + FIRST })).value).success) {
+            const read = values.flatMap((value) => {
+                const entry = Entry.safeParse(value);
+                return entry.success ? [entry.data] : [];
+            });
+            const reply = read.findLast((entry) => entry.role === "assistant");
+            const opening = read.find((entry) => entry.role === "user") ?? read[0];
+            const stored = {
+                title: opening ? titleOf(textOf(opening)) : "",
+                at: read[0]?.at ?? new Date().toISOString(),
+                // Behind every chat started since.
+                order: 0,
+                ...(reply ? { latest: { id: reply.id, at: reply.at } } : {}),
+                archived: false,
+            };
+            await store.set({ key: ENTRIES + FIRST, value: stored });
+        }
+        for (const [i, key] of keys.entries()) {
+            if (values[i] !== undefined)
+                await store.set({
+                    key: `${CHATS}${FIRST}/${key}`,
+                    value: values[i],
+                });
+            await store.delete({ key });
+        }
+        log.info("The conversation it had is now its first chat.", { messages: keys.length });
+    };
+    const load = () => {
+        if (loaded)
+            return loaded;
+        const attempt = (async () => {
+            await adopt();
+            const keys = await keysUnder(store, ENTRIES);
+            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 stored = Stored.safeParse(values[i]?.value);
+                    const id = key.slice(ENTRIES.length);
+                    if (!stored.success) {
+                        log.warn("A chat's entry didn't read back; the chat is left out.", { key });
+                        return;
+                    }
+                    chats.set(id, { id, stored: stored.data });
+                    top = Math.max(top, stored.data.order);
+                });
+            }
+            return chats;
+        })();
+        loaded = attempt;
+        attempt.catch(() => {
+            if (loaded === attempt)
+                loaded = undefined;
+        });
+        return attempt;
+    };
+    const heldOf = async (id) => {
+        const held = (await load()).get(id);
+        if (!held)
+            throw new Refused("unknown", "This agent has no such chat.");
+        return held;
+    };
+    return {
+        /**
+         * Say a message in a chat, or in a new chat it starts. With no turn in the chat it starts one;
+         * a turn running there takes it at its next model request.
+         */
+        async send({ chat, text }) {
+            if (chat !== undefined) {
+                await heldOf(chat);
+                const { messageId } = await looper.send(chat, text);
+                return { chat, messageId };
+            }
+            const found = await load();
+            const held = {
+                id: crypto.randomUUID(),
+                stored: {
+                    title: titleOf(text),
+                    at: new Date().toISOString(),
+                    order: ++top,
+                    archived: false,
+                },
+            };
+            try {
+                // Its entry first: a record with no entry would be a chat nobody can find.
+                await store.set({ key: ENTRIES + held.id, value: held.stored });
+                found.set(held.id, held);
+                const { messageId } = await looper.send(held.id, text);
+                return { chat: held.id, messageId };
+            }
+            catch (error) {
+                found.delete(held.id);
+                await store.delete({ key: ENTRIES + held.id }).catch(() => { });
+                throw error;
+            }
+        },
+        history: async ({ chat, before, limit }) => looper.page((await heldOf(chat)).id, before, limit ?? PAGE),
+        /** What the agent is doing now. */
+        state: stateNow,
+        /**
+         * The chats after `before` in the list, the one a message was last sent in first. `before`
+         * holds its place whether it is archived or not, so a page never leaves out a chat that hasn't
+         * moved since the page before it.
+         */
+        async list({ archived = false, before, limit = PAGE }) {
+            const found = await load();
+            const mark = before === undefined ? undefined : found.get(before);
+            if (before !== undefined && !mark)
+                return { chats: [], more: false };
+            const rest = [...found.values()]
+                .filter(({ stored }) => stored.archived === archived && (!mark || stored.order < mark.stored.order))
+                .sort((a, b) => b.stored.order - a.stored.order);
+            return { chats: rest.slice(0, limit).map(entryOf), more: rest.length > limit };
+        },
+        async rename({ chat, title }) {
+            await keep(await heldOf(chat), "title", titleOf(title));
+            return {};
+        },
+        async archive({ chat, archived }) {
+            await keep(await heldOf(chat), "archived", archived);
+            return {};
+        },
+        /**
+         * Stop the agent: its turns are cut, and none starts until it is started. A call already
+         * running finishes first, so this answers when nothing more will be written. Its chats stay as
+         * they are, to be read.
+         */
+        stop: () => looper.stop(),
+        start: () => looper.start(),
+        /** Go on with the turns that were cut off when the agent last ran, each once. */
+        async resume() {
+            // The chats first: what a turn says moves its chat in the list.
+            await load();
+            await looper.resume();
+        },
+        /**
+         * Close for good: its turns are cut, and none starts after. They stay marked, so the engine
+         * that opens this store next goes on with them.
+         */
+        close: () => looper.close(),
+        /** Settles when every chat's latest turn has written all it will. */
+        async settled() {
+            await loaded?.catch(() => undefined);
+            await looper.settled();
+            await writing;
+        },
+        /** Streamed text of the model request running now. */
+        delta(requestId, text) {
+            looper.delta(requestId, text);
+        },
+    };
+}