@agentshouse/mdruntime 0.1.0-cf96c797c5fa8 → 0.1.0-cf9a84afc6def

package/dist/conversation.js

@@ -1,14 +1,29 @@
 import { conversationChangeSet } from './change-set.js';
 import { runtimeError } from './failure.js';
-import { declaredFile } from './file.js';
-import { chatDraftRevision } from './identity.js';
+import { refusedForSpace } from './durability.js';
+import { changeBatchIdentity, chatDraftRevision } from './identity.js';
+import { OFFLINE } from './outcome.js';
+import { untilAnswered } from './recovery.js';
+import { capped, cursorOf, decodedCursor, FROM_START, messageOrder, precedes } from './windows.js';
 const QUIET = {
     turn: null,
     questions: [],
     process: null,
     commands: [],
     options: [],
+    starting: null,
+    link: null,
+    deliveryUnknown: [],
 };
+const FACTS = [
+    'questions',
+    'process',
+    'commands',
+    'options',
+    'starting',
+    'link',
+    'deliveryUnknown',
+];
 export function unheldView(conversation) {
     return {
         conversation,
@@ -18,9 +33,26 @@ export function unheldView(conversation) {
         process: null,
         commands: [],
         options: [],
+        starting: null,
+        link: null,
+        deliveryUnknown: [],
         chatDraft: null,
     };
 }
+export const SESSION_STARTED = 'Session started';
+const NEW_CHAT = 'new:';
+export const HISTORY_CONVERSATIONS = 64;
+export function newChat(agent) {
+    return `${NEW_CHAT}${agent}`;
+}
+function creationOf(input) {
+    if (typeof input !== 'object' || input === null)
+        return null;
+    const { agent_id: agent, operation_id: operation, replaces, } = input;
+    return typeof agent === 'string' && typeof operation === 'string' && replaces === undefined
+        ? { agent, operation }
+        : null;
+}
 function startedTurn(turn, operation) {
     if (operation.op === 'begin')
         return { turn, started: operation.at, parts: [], context: null };
@@ -70,18 +102,28 @@ function appliedTurn(held, operation) {
         parts: held.parts.map((kept, at) => (at === operation.index ? changed : kept)),
     };
 }
-function ordered(left, right) {
-    if (left.position !== right.position)
-        return left.position < right.position ? -1 : 1;
-    if (left.identity !== right.identity)
-        return left.identity < right.identity ? -1 : 1;
-    return 0;
-}
-function merged(held, arriving) {
+function windowOf(held, arriving, limit) {
     const byIdentity = new Map(held.map((message) => [message.identity, message]));
     for (const message of arriving)
         byIdentity.set(message.identity, message);
-    return [...byIdentity.values()].sort(ordered);
+    const next = [...byIdentity.values()].sort(messageOrder);
+    const start = Math.max(0, next.length - limit);
+    return { messages: next.slice(start), dropped: start > 0 };
+}
+function frameOf(asked, messages, more, total) {
+    const oldest = messages[0];
+    const next = !more
+        ? undefined
+        : oldest === undefined
+            ? (asked.after ?? FROM_START)
+            : cursorOf([oldest.position, oldest.identity]);
+    return {
+        ...(next === undefined ? {} : { next }),
+        ...(total === null ? {} : { total }),
+    };
+}
+function newestOf(arriving, from) {
+    return arriving.reduce((top, message) => (top === null || message.position > top ? message.position : top), from);
 }
 function acceptedMessage(value) {
     if (typeof value !== 'object' || value === null)
@@ -140,88 +182,160 @@ function historyPages(result) {
     }
     return pages;
 }
-function turnOf(result) {
+function answered(result, field) {
     if (result.kind !== 'action')
         return null;
     const answer = result.result;
     if (typeof answer !== 'object' || answer === null)
         return null;
-    const record = answer;
-    return typeof record.turn === 'string' ? record.turn : null;
+    const value = answer[field];
+    return typeof value === 'string' ? value : null;
 }
-function limitOf(options) {
-    const { limit } = options;
-    if (limit === undefined)
-        return undefined;
-    if (!Number.isInteger(limit) || limit < 0) {
+function beforeOf(after) {
+    if (after === undefined)
+        return null;
+    const decoded = typeof after === 'string' ? decodedCursor(after) : null;
+    if (decoded?.length === 0)
+        return null;
+    const [position, identity] = decoded ?? [];
+    if (decoded?.length !== 2 || typeof position !== 'string' || typeof identity !== 'string') {
+        throw runtimeError('invalid-after', `conversation after must be the next an earlier view returned, got ${String(after)}`);
+    }
+    return [position, identity];
+}
+function askedOf(options) {
+    const { limit, after, total } = options;
+    if (limit !== undefined && (!Number.isInteger(limit) || limit < 0)) {
         throw runtimeError('invalid-limit', `conversation limit must be a non-negative integer, got ${String(limit)}`);
     }
-    return limit;
+    return { limit: capped(limit), after, before: beforeOf(after), total: total === true };
+}
+const EXPIRED = { kind: 'rejected', code: 'expired', fields: {}, retryable: false };
+const DURABLE_WRITE = {
+    kind: 'rejected',
+    code: 'durable-write',
+    fields: {},
+    retryable: true,
+};
+function unwritten(draft) {
+    return draft.text === '';
+}
+function pending(draft) {
+    return {
+        ...(draft.submitted === undefined ? {} : { submitted: draft.submitted }),
+        ...(draft.moves === undefined ? {} : { moves: draft.moves }),
+    };
+}
+function empty(draft) {
+    return unwritten(draft) && draft.submitted === undefined && draft.moves === undefined;
+}
+function withSubmitted(draft, submitted) {
+    const { submitted: _held, ...unsent } = draft;
+    return submitted.length === 0 ? unsent : { ...unsent, submitted };
+}
+function prepended(draft, said) {
+    return { text: [said.text, draft.text].filter((one) => one !== '').join('\n') };
+}
+function returned(draft, submission, others) {
+    return withSubmitted({
+        conversation: draft.conversation,
+        ...prepended(draft, submission),
+        revision: chatDraftRevision(),
+    }, others);
 }
 export function createConversationStore(deps) {
-    const messages = new Map();
+    const stored = new Set();
     const reads = new Map();
+    const partials = new Set();
     const drafts = new Map();
     const sending = new Map();
     const behind = new Set();
+    const catching = new Map();
     const gaps = new Map();
     const lives = new Map();
+    const unsent = new Map();
     const views = new Map();
     const listing = new Map();
+    const creations = new Set();
     const listWatchers = new Set();
+    const unlisted = new Set();
     let listKnown = false;
+    let listHeld = false;
+    let listKept = false;
     const agentWatchers = new Set();
-    let agentNames = new Map();
-    let retiredAgents = new Set();
-    let agentsRead = null;
+    const unnamed = new Set();
+    let agentsShown = null;
+    let listedAgents = null;
+    let agentsReading = false;
     let replicated = new Set();
     let handedReplicated;
     function liveOf(conversation) {
         return lives.get(conversation) ?? QUIET;
     }
-    function shownMessages(conversation, limit) {
-        const held = messages.get(conversation) ?? [];
-        const shown = limit === undefined ? held : held.slice(Math.max(0, held.length - limit));
-        return shown.map(({ identity, turn, text, message }) => ({
-            identity,
-            turn,
-            text,
-            message: structuredClone(message),
-        }));
-    }
-    function viewOf(conversation, limit, shown = shownMessages(conversation, limit)) {
+    function viewOf(conversation, held, frame) {
         const draft = drafts.get(conversation);
         const facts = liveOf(conversation);
         return {
             conversation,
-            messages: shown,
+            messages: held.map(({ identity, turn, text, message }) => ({
+                identity,
+                turn,
+                text,
+                message,
+            })),
+            ...frame,
             turn: structuredClone(facts.turn),
             questions: structuredClone(facts.questions),
             process: facts.process === null ? null : { ...facts.process },
             commands: structuredClone(facts.commands),
             options: structuredClone(facts.options),
-            chatDraft: draft === undefined || draft.turn !== null || sending.get(conversation)?.draft === draft
+            starting: facts.starting,
+            link: facts.link === null ? null : { ...facts.link },
+            deliveryUnknown: [...facts.deliveryUnknown],
+            chatDraft: draft === undefined || unwritten(draft)
                 ? null
-                : { text: draft.text, files: [...draft.files], revision: draft.revision },
+                : { text: draft.text, revision: draft.revision },
         };
     }
-    function emit(conversation, messagesChanged = true) {
+    function emit(conversation) {
         if (deps.closed())
             return;
         for (const view of views.values()) {
-            if (view.conversation !== conversation)
+            if (view.conversation !== conversation || view.window === null)
                 continue;
-            if (messagesChanged)
-                view.messages = null;
             const ready = [...view.watchers].filter((watcher) => watcher.ready);
             if (ready.length === 0)
                 continue;
-            view.messages ??= shownMessages(conversation, view.limit);
-            const value = viewOf(conversation, view.limit, view.messages);
+            const value = viewOf(conversation, view.window, sharedFrame(view, view.window));
             for (const watcher of ready)
                 watcher.notify(value);
         }
     }
+    function sharedFrame(view, window) {
+        return frameOf(view.asked, window, view.more, view.total);
+    }
+    async function slide(local, conversation, arriving) {
+        let count;
+        for (const view of views.values()) {
+            if (view.conversation !== conversation || view.window === null)
+                continue;
+            if (arriving === null) {
+                view.window = [];
+                view.more = false;
+                if (view.total !== null)
+                    view.total = 0;
+                continue;
+            }
+            const joining = arriving.filter((message) => precedes(message, view.asked.before));
+            const next = windowOf(view.window, joining, view.asked.limit);
+            view.window = next.messages;
+            view.more ||= next.dropped;
+            if (view.total !== null && arriving.length > 0) {
+                count ??= await local.messageCount(conversation);
+                view.total = count;
+            }
+        }
+    }
     function stateOf(conversation) {
         const facts = liveOf(conversation);
         if (facts.questions.length > 0)
@@ -231,34 +345,100 @@ export function createConversationStore(deps) {
     function entries() {
         return [...listing.values()].map((entry) => ({
             conversation: entry.conversation,
-            agent: { identity: entry.agent, name: agentNames.get(entry.agent) ?? null },
+            agent: { identity: entry.agent, name: entry.agentName },
             name: entry.name,
             created: entry.created,
             finished: entry.finished,
             outcome: entry.outcome,
+            waiting: entry.waiting,
             state: stateOf(entry.conversation),
             started: lives.get(entry.conversation)?.turn?.started ?? null,
         }));
     }
+    function keepList() {
+        if (!listKnown || listKept)
+            return;
+        listKept = true;
+        queueMicrotask(() => {
+            listKept = false;
+            if (deps.closed())
+                return;
+            const entries = [...listing.values()];
+            void deps.durably((local) => local.fact('conversationList', entries)).catch(() => { });
+        });
+    }
     function emitList() {
-        if (deps.closed() || listWatchers.size === 0)
+        if (deps.closed())
             return;
-        const value = entries();
-        for (const watcher of listWatchers)
-            watcher(value);
+        if (listWatchers.size > 0) {
+            const value = entries();
+            for (const watcher of listWatchers)
+                watcher(value);
+        }
+        emitAgents();
+        learned();
+    }
+    function learned() {
+        if (deps.closed())
+            return;
+        if (!listKnown && !listHeld && deps.stream() !== undefined && deps.online())
+            return;
+        if (unlisted.size > 0) {
+            const value = entries();
+            for (const watcher of [...unlisted]) {
+                unlisted.delete(watcher);
+                listWatchers.add(watcher);
+                watcher(value);
+            }
+        }
+        if (unnamed.size > 0) {
+            const value = agents();
+            for (const watcher of [...unnamed]) {
+                unnamed.delete(watcher);
+                agentWatchers.add(watcher);
+                watcher(value);
+            }
+        }
     }
     function agents() {
-        return [...agentNames]
-            .filter(([identity]) => !retiredAgents.has(identity))
-            .map(([identity, name]) => ({ identity, name }))
+        const named = new Map();
+        for (const agent of listedAgents ?? [])
+            named.set(agent.agent, agent);
+        for (const entry of listing.values()) {
+            named.set(entry.agent, { name: entry.agentName, retired: entry.agentRetired });
+        }
+        return [...named]
+            .filter(([, agent]) => !agent.retired)
+            .map(([identity, agent]) => ({ identity, name: agent.name }))
             .sort((left, right) => left.name === right.name
             ? left.identity.localeCompare(right.identity)
             : left.name.localeCompare(right.name));
     }
+    function readAgents() {
+        const stream = deps.stream();
+        if (stream?.agents === undefined || !deps.online() || agentsReading)
+            return;
+        agentsReading = true;
+        void stream
+            .agents()
+            .then((read) => {
+            if (read === null)
+                return;
+            listedAgents = read;
+            emitAgents();
+        }, () => { })
+            .finally(() => {
+            agentsReading = false;
+        });
+    }
     function emitAgents() {
         if (deps.closed() || agentWatchers.size === 0)
             return;
         const value = agents();
+        const shown = JSON.stringify(value);
+        if (shown === agentsShown)
+            return;
+        agentsShown = shown;
         for (const watcher of agentWatchers)
             watcher(value);
     }
@@ -274,43 +454,40 @@ export function createConversationStore(deps) {
         if (stateOf(conversation) !== before || next?.turn?.started !== began)
             emitList();
     }
-    async function readAgents() {
-        const declaration = deps.agents();
-        if (declaration === undefined)
-            return;
-        const { documents } = await deps.documents(declaration.locator);
-        const names = new Map();
-        const retired = new Set();
-        for (const document of documents) {
-            if (document.type !== declaration.type)
-                continue;
-            const identity = document.fields?.[declaration.identity];
-            const name = document.fields?.[declaration.name];
-            if (typeof identity !== 'string' || typeof name !== 'string')
-                continue;
-            names.set(identity, name);
-            const ended = declaration.retired === undefined ? null : document.fields?.[declaration.retired];
-            if (ended !== undefined && ended !== null)
-                retired.add(identity);
-        }
-        const named = JSON.stringify([...names]) !== JSON.stringify([...agentNames]);
-        if (!named && JSON.stringify([...retired]) === JSON.stringify([...retiredAgents]))
-            return;
-        agentNames = names;
-        retiredAgents = retired;
-        if (named)
-            emitList();
-        emitAgents();
-    }
-    function agentsReady() {
-        agentsRead ??= readAgents().catch(() => {
-            agentsRead = null;
-        });
-        return agentsRead;
+    function retiredChat(conversation) {
+        if (!conversation.startsWith(NEW_CHAT))
+            return false;
+        const agent = conversation.slice(NEW_CHAT.length);
+        return [...listing.values()].some((entry) => entry.agent === agent && entry.agentRetired);
     }
     function live(conversation, change) {
+        const owed = unsent.get(conversation);
+        for (const fact of FACTS.filter((one) => one in change))
+            owed?.delete(fact);
         setLive(conversation, { ...liveOf(conversation), ...change });
-        emit(conversation, false);
+        emit(conversation);
+    }
+    function openingEnded() {
+        const owed = [...unsent];
+        unsent.clear();
+        for (const [conversation, facts] of owed) {
+            const held = lives.get(conversation);
+            if (held === undefined || facts.size === 0)
+                continue;
+            setLive(conversation, {
+                turn: held.turn,
+                questions: facts.has('questions') ? QUIET.questions : held.questions,
+                process: facts.has('process') ? QUIET.process : held.process,
+                commands: facts.has('commands') ? QUIET.commands : held.commands,
+                options: facts.has('options') ? QUIET.options : held.options,
+                starting: facts.has('starting') ? QUIET.starting : held.starting,
+                link: facts.has('link') ? QUIET.link : held.link,
+                deliveryUnknown: facts.has('deliveryUnknown')
+                    ? QUIET.deliveryUnknown
+                    : held.deliveryUnknown,
+            });
+            emit(conversation);
+        }
     }
     function relayed(conversation, turn, operation) {
         const held = liveOf(conversation).turn;
@@ -339,25 +516,38 @@ export function createConversationStore(deps) {
     async function remove(leaving) {
         await deps.durably(async (local) => {
             await local.dropConversations(leaving);
-            const removed = [];
             const changed = [];
             for (const conversation of leaving) {
-                for (const message of messages.get(conversation) ?? []) {
-                    removed.push({ conversation, identity: message.identity });
-                }
-                if (messages.has(conversation) || drafts.has(conversation) || lives.has(conversation)) {
+                if (stored.has(conversation) || drafts.has(conversation) || lives.has(conversation)) {
                     changed.push(conversation);
                 }
-                messages.delete(conversation);
+                stored.delete(conversation);
                 reads.delete(conversation);
+                partials.delete(conversation);
                 drafts.delete(conversation);
                 behind.delete(conversation);
+                unsent.delete(conversation);
                 setLive(conversation, null);
+                await slide(local, conversation, null);
             }
             if (changed.length > 0)
-                deps.publish(conversationChangeSet(removed, changed));
+                deps.publish(conversationChangeSet(changed));
         });
     }
+    function missed(conversation) {
+        const read = reads.get(conversation);
+        const newest = listing.get(conversation)?.newest;
+        return (read === undefined ||
+            newest === undefined ||
+            partials.has(conversation) ||
+            (newest !== null && (read === null || newest > read)));
+    }
+    function noted(conversation, message) {
+        const entry = listing.get(conversation);
+        if (entry === undefined || (entry.newest !== null && entry.newest >= message.position))
+            return;
+        listing.set(conversation, { ...entry, newest: message.position });
+    }
     function gap(conversation) {
         gaps.set(conversation, (gaps.get(conversation) ?? 0) + 1);
         behind.add(conversation);
@@ -370,33 +560,29 @@ export function createConversationStore(deps) {
             const advances = read !== undefined &&
                 !behind.has(conversation) &&
                 (read === null || message.position > read);
-            const sealed = drafts.get(conversation)?.turn === message.turn;
+            await sealed(local, conversation, new Set([message.turn]));
             await local.keepMessages({
                 conversation,
                 messages: [message],
-                ...(advances ? { read: message.position } : {}),
-                sealed,
+                ...(advances ? { read: { at: message.position, partial: false } } : {}),
             });
-            messages.set(conversation, merged(messages.get(conversation) ?? [], [message]));
+            stored.add(conversation);
             if (advances)
                 reads.set(conversation, message.position);
-            if (sealed)
-                drafts.delete(conversation);
             sealTurns(conversation, new Set([message.turn]));
-            deps.publish(conversationChangeSet([{ conversation, identity: message.identity }], [conversation]));
+            await slide(local, conversation, [message]);
+            deps.publish(conversationChangeSet([conversation]));
         });
     }
-    async function readHistories(conversations) {
+    async function readHistories(conversations, ended) {
         const generations = new Map(conversations.map((one) => [one, gaps.get(one) ?? 0]));
-        const starts = new Map(conversations.map((one) => [one, reads.get(one)]));
-        const arriving = new Map();
-        const complete = new Set();
-        let asking = conversations.map((conversation) => ({
+        let waiting = conversations.map((conversation) => ({
             conversation,
-            after: starts.get(conversation) ?? undefined,
+            after: reads.get(conversation) ?? undefined,
         }));
-        while (asking.length > 0) {
-            const result = await deps.call('conversation.history', {
+        while (waiting.length > 0) {
+            const asking = waiting.slice(0, HISTORY_CONVERSATIONS);
+            const result = await deps.history({
                 conversations: asking.map(({ conversation, after }) => ({
                     conversation,
                     ...(after === undefined ? {} : { after }),
@@ -405,46 +591,64 @@ export function createConversationStore(deps) {
             const pages = historyPages(result);
             if (pages === null)
                 return result;
-            const asked = new Set(asking.map(({ conversation }) => conversation));
+            const asked = new Map(asking.map(({ conversation, after }) => [conversation, after]));
             const following = [];
             for (const page of pages) {
                 if (!asked.has(page.conversation))
                     continue;
-                arriving.set(page.conversation, [
-                    ...(arriving.get(page.conversation) ?? []),
-                    ...page.messages,
-                ]);
-                if (page.next === undefined)
-                    complete.add(page.conversation);
-                else
+                await keepPage(page.conversation, page.messages, asked.get(page.conversation) ?? null, page.next, generations.get(page.conversation) ?? 0);
+                if (page.next !== undefined) {
                     following.push({ conversation: page.conversation, after: page.next });
+                }
             }
-            asking = following;
-        }
-        for (const [conversation, held] of arriving) {
-            if (!complete.has(conversation))
-                continue;
-            await keepHistory(conversation, held, starts.get(conversation), generations.get(conversation) ?? 0);
+            for (const { conversation } of asking) {
+                if (!following.some((next) => next.conversation === conversation))
+                    ended(conversation);
+            }
+            waiting = [...waiting.slice(HISTORY_CONVERSATIONS), ...following];
         }
         return null;
     }
-    function keepHistory(conversation, arriving, from, generation) {
+    function caughtUp(conversations) {
+        const ends = new Map();
+        for (const conversation of conversations) {
+            const held = new Promise((end) => ends.set(conversation, end));
+            catching.set(conversation, held);
+            void held.then(() => {
+                if (catching.get(conversation) === held)
+                    catching.delete(conversation);
+            });
+        }
+        const ended = (conversation) => ends.get(conversation)?.();
+        const read = readHistories(conversations, ended);
+        const endAll = () => {
+            for (const conversation of conversations)
+                ended(conversation);
+        };
+        read.then(endAll, endAll);
+        return read;
+    }
+    function keepPage(conversation, arriving, from, next, generation) {
         return deps.durably(async (local) => {
             if (!replicated.has(conversation))
                 return;
-            const newest = arriving.reduce((top, message) => (top === null || message.position > top ? message.position : top), from ?? null);
-            const turn = drafts.get(conversation)?.turn;
-            const sealed = arriving.some((message) => message.turn === turn);
-            await local.keepMessages({ conversation, messages: arriving, read: newest, sealed });
-            messages.set(conversation, merged(messages.get(conversation) ?? [], arriving));
-            reads.set(conversation, newest);
-            if (sealed)
-                drafts.delete(conversation);
+            const whole = next === undefined;
+            const cursor = next ?? newestOf(arriving, from);
+            const partial = !whole && (partials.has(conversation) || !reads.has(conversation));
+            const sealing = await sealed(local, conversation, new Set(arriving.map((message) => message.turn)));
+            await local.keepMessages({ conversation, messages: arriving, read: { at: cursor, partial } });
+            stored.add(conversation);
+            reads.set(conversation, cursor);
+            if (partial)
+                partials.add(conversation);
+            else
+                partials.delete(conversation);
             sealTurns(conversation, new Set(arriving.map((message) => message.turn)));
-            if ((gaps.get(conversation) ?? 0) === generation)
+            if (whole && (gaps.get(conversation) ?? 0) === generation)
                 behind.delete(conversation);
-            if (arriving.length > 0 || sealed) {
-                deps.publish(conversationChangeSet(arriving.map((message) => ({ conversation, identity: message.identity })), [conversation]));
+            await slide(local, conversation, arriving);
+            if (arriving.length > 0 || sealing || whole) {
+                deps.publish(conversationChangeSet([conversation]));
             }
         });
     }
@@ -453,11 +657,8 @@ export function createConversationStore(deps) {
         if (event.kind === 'gap') {
             if (replicated.has(conversation))
                 gap(conversation);
-            const held = lives.get(conversation);
-            if (held === undefined)
-                return;
-            setLive(conversation, { ...QUIET, turn: held.turn });
-            emit(conversation, false);
+            if (lives.has(conversation))
+                unsent.set(conversation, new Set(FACTS));
             return;
         }
         if (event.kind === 'turn') {
@@ -480,143 +681,284 @@ export function createConversationStore(deps) {
             live(conversation, { options: structuredClone(event.options) });
             return;
         }
+        if (event.kind === 'starting') {
+            live(conversation, { starting: event.step });
+            return;
+        }
+        if (event.kind === 'link') {
+            live(conversation, { link: { connected: event.connected } });
+            return;
+        }
+        if (event.kind === 'deliveries') {
+            live(conversation, { deliveryUnknown: [...event.unknown] });
+            return;
+        }
         const arriving = acceptedMessage(event.message);
         if (arriving === null)
             return;
+        noted(conversation, arriving);
         if (replicated.has(conversation)) {
-            void keep(conversation, arriving).catch(() => { });
+            if (deps.full()) {
+                gap(conversation);
+                return;
+            }
+            void keep(conversation, arriving).catch((error) => {
+                if (refusedForSpace(error))
+                    gap(conversation);
+            });
             return;
         }
         if (sealTurns(conversation, new Set([arriving.turn])))
             emit(conversation);
     }
+    async function kept(local, conversation, following) {
+        if (following === null || empty(following)) {
+            await local.dropChatDraft(conversation);
+            drafts.delete(conversation);
+        }
+        else {
+            await local.keepChatDrafts([following]);
+            drafts.set(conversation, following);
+        }
+    }
+    async function sealed(local, conversation, turns) {
+        const held = drafts.get(conversation);
+        const submitted = held?.submitted ?? [];
+        const left = submitted.filter((one) => one.turn === null || !turns.has(one.turn));
+        if (held === undefined || left.length === submitted.length)
+            return false;
+        await kept(local, conversation, withSubmitted(held, left));
+        return true;
+    }
+    function moved(agent, operation, to) {
+        const from = newChat(agent);
+        return deps.durably(async (local) => {
+            const held = drafts.get(from);
+            const earlier = (held?.moves ?? []).filter((one) => !deps.expired(one));
+            if (earlier.includes(operation))
+                return;
+            const blank = {
+                conversation: from,
+                text: '',
+                revision: chatDraftRevision(),
+            };
+            const { moves: _answered, ...unsent } = held ?? blank;
+            const taken = drafts.has(to) || empty(unsent) ? [] : [{ ...unsent, conversation: to }];
+            const left = { ...(taken.length === 0 ? unsent : blank), moves: [...earlier, operation] };
+            await local.keepChatDrafts([left, ...taken]);
+            drafts.set(from, left);
+            for (const one of taken)
+                drafts.set(to, one);
+            deps.publish(conversationChangeSet([from, to]));
+        });
+    }
     function withDraft(conversation, next) {
         return deps.durably(async (local) => {
-            const following = next(drafts.get(conversation));
+            const following = await next(drafts.get(conversation), local);
             if (following === undefined)
                 return;
-            if (following === null) {
-                await local.dropChatDraft(conversation);
-                drafts.delete(conversation);
-            }
-            else {
-                await local.keepChatDraft(following);
-                drafts.set(conversation, following);
-            }
-            deps.publish(conversationChangeSet([], [conversation]));
+            await kept(local, conversation, following);
+            deps.publish(conversationChangeSet([conversation]));
         });
     }
-    function invoke(name, conversation, extra = {}) {
-        return deps.call(name, { conversation, ...extra });
+    async function submitted(conversation, operation, draft) {
+        let submission;
+        let earlier = false;
+        await withDraft(conversation, (current) => {
+            submission = current?.submitted?.find((one) => one.operation === operation);
+            earlier = submission !== undefined;
+            if (submission !== undefined)
+                return undefined;
+            const said = draft ?? current;
+            submission = { operation, text: said?.text ?? '', turn: null };
+            return {
+                conversation,
+                ...(draft === undefined || current === undefined
+                    ? { text: '', revision: chatDraftRevision() }
+                    : { text: current.text, revision: current.revision }),
+                submitted: [...(current?.submitted ?? []), submission],
+            };
+        });
+        return { submission: submission, earlier };
+    }
+    function forgotten(conversation, submission) {
+        return withDraft(conversation, (current) => {
+            const held = current?.submitted ?? [];
+            if (current === undefined || !held.includes(submission))
+                return undefined;
+            return withSubmitted(current, held.filter((one) => one !== submission));
+        });
+    }
+    async function dispatched(conversation, submission) {
+        const dispatch = { answered: false };
+        sending.set(submission.operation, dispatch);
+        try {
+            const result = await invoke('conversations/send', conversation, {
+                operation_id: submission.operation,
+                text: submission.text,
+            });
+            dispatch.answered = result.kind !== 'transport-uncertainty';
+            if (result.kind === 'revoked-authorization')
+                return result;
+            if (result.kind !== 'action' && result.retryable) {
+                deps.unanswered();
+                return result;
+            }
+            const turn = answered(result, 'message_id');
+            await withDraft(conversation, async (current, local) => {
+                const held = current?.submitted?.find((one) => one.operation === submission.operation);
+                if (current === undefined || held === undefined || held.turn !== null)
+                    return undefined;
+                const others = current.submitted.filter((one) => one !== held);
+                if (result.kind !== 'action')
+                    return returned(current, held, others);
+                const arrived = turn !== null && (await local.turnArrived(conversation, turn));
+                return withSubmitted(current, turn === null || arrived
+                    ? others
+                    : current.submitted.map((one) => (one === held ? { ...held, turn } : one)));
+            });
+            return result;
+        }
+        finally {
+            if (sending.get(submission.operation) === dispatch)
+                sending.delete(submission.operation);
+        }
+    }
+    function invoke(name, conversation, extra = { operation_id: changeBatchIdentity() }) {
+        return deps.call(name, { conversation_id: conversation, ...extra });
     }
     const surface = {
-        async list() {
-            await agentsReady();
-            return entries();
+        list() {
+            return new Promise((settle) => {
+                const answer = (listed) => {
+                    unlisted.delete(answer);
+                    listWatchers.delete(answer);
+                    settle(listed);
+                };
+                unlisted.add(answer);
+                learned();
+            });
         },
         async read(conversation, options = {}) {
-            const limit = limitOf(options);
-            return deps.durably(() => Promise.resolve(viewOf(conversation, limit)));
+            const asked = askedOf(options);
+            return deps.durably(async (local) => {
+                const { messages, more } = await local.messageWindow(conversation, asked.limit, asked.before);
+                const total = asked.total ? await local.messageCount(conversation) : null;
+                return structuredClone(viewOf(conversation, messages, frameOf(asked, messages, more, total)));
+            });
         },
-        create(input) {
-            return deps.call('conversation.create', input);
+        async create(input) {
+            const result = await deps.call('conversations/create', input);
+            const conversation = answered(result, 'conversation_id');
+            if (conversation === null)
+                return result;
+            if (!listing.has(conversation))
+                creations.add(conversation);
+            const creation = creationOf(input);
+            if (creation !== null)
+                await moved(creation.agent, creation.operation, conversation);
+            return result;
         },
-        async send(conversation) {
-            const draft = drafts.get(conversation);
-            const pending = draft === undefined ? undefined : { draft };
-            if (pending !== undefined) {
-                sending.set(conversation, pending);
-                deps.publish(conversationChangeSet([], [conversation]));
-            }
-            try {
-                const files = await Promise.all((draft?.files ?? []).map(async (file) => ({
-                    ...(await declaredFile(file)),
-                    blob: file.blob,
-                })));
-                const result = await invoke('conversation.send', conversation, {
-                    text: draft?.text ?? '',
-                    files,
-                });
-                const turn = turnOf(result);
-                if (turn === null || draft === undefined)
-                    return result;
-                await withDraft(conversation, (current) => {
-                    if (current !== draft)
-                        return undefined;
-                    const sealed = (messages.get(conversation) ?? []).some((message) => message.turn === turn);
-                    return sealed ? null : { ...draft, turn };
+        async send(conversation, operation = changeBatchIdentity(), draft) {
+            if (deps.full())
+                return DURABLE_WRITE;
+            if (deps.online()) {
+                const held = await submitted(conversation, operation, draft).catch((error) => {
+                    if (refusedForSpace(error))
+                        return null;
+                    throw error;
                 });
-                return result;
+                if (held === null)
+                    return DURABLE_WRITE;
+                const { submission, earlier } = held;
+                if (!earlier || !deps.expired(operation))
+                    return dispatched(conversation, submission);
+                await forgotten(conversation, submission);
+                return EXPIRED;
             }
-            finally {
-                if (pending !== undefined && sending.get(conversation) === pending) {
-                    sending.delete(conversation);
-                    if (drafts.get(conversation) === draft) {
-                        deps.publish(conversationChangeSet([], [conversation]));
-                    }
-                }
+            if (draft !== undefined) {
+                await withDraft(conversation, (current) => current?.submitted?.some((one) => one.operation === operation) === true
+                    ? undefined
+                    : returned(current ?? { conversation, text: '', revision: '' }, { operation, ...draft, turn: null }, current?.submitted ?? []));
             }
+            return OFFLINE;
         },
         answer(conversation, answer) {
-            return invoke('conversation.answer', conversation, { answer });
+            return invoke('conversations/interaction/answer', conversation, {
+                operation_id: changeBatchIdentity(),
+                ...answer,
+            });
         },
         interrupt(conversation) {
-            return invoke('conversation.interrupt', conversation);
+            return invoke('conversations/interrupt', conversation);
         },
         kill(conversation) {
-            return invoke('conversation.kill', conversation);
-        },
-        async cancel(conversation, turn) {
-            const result = await invoke('conversation.cancel', conversation, { turn });
-            if (result.kind !== 'action')
-                return result;
-            await withDraft(conversation, (current) => current === undefined || current.turn !== turn ? undefined : { ...current, turn: null });
-            return result;
+            return invoke('conversations/kill', conversation);
         },
         delete(conversation) {
-            return invoke('conversation.delete', conversation);
+            return invoke('conversations/delete', conversation);
         },
     };
     const chatDraft = {
         write(conversation, draft, revision = chatDraftRevision()) {
-            return withDraft(conversation, () => ({
+            return withDraft(conversation, (current) => ({
                 conversation,
                 text: draft.text,
-                files: [...draft.files],
-                turn: null,
                 revision,
+                ...(current === undefined ? {} : pending(current)),
+            }));
+        },
+        prepend(conversation, draft) {
+            return withDraft(conversation, (current) => ({
+                conversation,
+                ...(current === undefined ? { text: draft.text } : prepended(current, draft)),
+                revision: chatDraftRevision(),
+                ...(current === undefined ? {} : pending(current)),
             }));
         },
         discard(conversation) {
-            return withDraft(conversation, (current) => (current === undefined ? undefined : null));
+            return withDraft(conversation, (current) => current === undefined
+                ? undefined
+                : { conversation, text: '', revision: chatDraftRevision(), ...pending(current) });
         },
     };
     return {
         surface,
         chatDraft,
-        hydrate(held, stored) {
-            messages.clear();
+        hydrate(held, kept, list) {
+            if (list !== null && !listKnown) {
+                listing.clear();
+                for (const entry of list)
+                    listing.set(entry.conversation, { ...entry });
+                listHeld = true;
+            }
+            stored.clear();
             reads.clear();
-            for (const view of views.values())
-                view.messages = null;
+            partials.clear();
             for (const entry of held) {
-                messages.set(entry.conversation, [...entry.messages].sort(ordered));
+                stored.add(entry.conversation);
                 if (entry.read !== undefined)
                     reads.set(entry.conversation, entry.read);
+                if (entry.partial)
+                    partials.add(entry.conversation);
             }
             drafts.clear();
-            for (const record of stored)
+            for (const record of kept)
                 drafts.set(record.conversation, record);
+            if (listHeld)
+                learned();
         },
         async reconcile() {
             if (!listKnown)
                 return;
             const named = new Set(listing.keys());
             const leaving = [
-                ...new Set([...replicated, ...messages.keys(), ...reads.keys(), ...drafts.keys()]),
-            ].filter((conversation) => !named.has(conversation));
+                ...new Set([...replicated, ...stored, ...reads.keys(), ...drafts.keys()]),
+            ].filter((conversation) => !named.has(conversation) &&
+                !creations.has(conversation) &&
+                (!conversation.startsWith(NEW_CHAT) || retiredChat(conversation)));
             for (const conversation of named) {
-                if (!replicated.has(conversation))
+                if (!replicated.has(conversation) && missed(conversation))
                     behind.add(conversation);
             }
             replicated = named;
@@ -625,44 +967,100 @@ export function createConversationStore(deps) {
                 await remove(leaving);
         },
         async catchUp(progress) {
-            const reading = [...behind].filter((conversation) => replicated.has(conversation)).sort();
-            if (reading.length > 0 && !deps.closed()) {
-                const failed = await readHistories(reading);
+            if (deps.full()) {
+                if (behind.size > 0)
+                    progress.complete = false;
+                return;
+            }
+            const owed = (conversation) => behind.has(conversation) && replicated.has(conversation);
+            const read = async (conversations) => {
+                if (conversations.length === 0 || deps.closed())
+                    return;
+                const failed = await caughtUp(conversations);
                 if (failed?.kind === 'transport-uncertainty')
                     progress.reachable = false;
-            }
+            };
+            const asking = [...behind].filter(owed).sort();
+            const awaited = asking.filter((conversation) => catching.has(conversation));
+            await Promise.all([
+                read(asking.filter((conversation) => !catching.has(conversation))),
+                Promise.all(awaited.map((conversation) => catching.get(conversation))).then(() => read(awaited.filter((conversation) => owed(conversation) && !catching.has(conversation)))),
+            ]);
             if (behind.size > 0)
                 progress.complete = false;
         },
+        async resend(progress) {
+            for (const [conversation, held] of [...drafts]) {
+                for (const submission of held.submitted ?? []) {
+                    if (submission.turn !== null || sending.has(submission.operation))
+                        continue;
+                    if (deps.closed())
+                        return;
+                    if (deps.expired(submission.operation)) {
+                        await forgotten(conversation, submission);
+                        continue;
+                    }
+                    const result = await dispatched(conversation, submission);
+                    if (result.kind === 'revoked-authorization')
+                        return;
+                    if (result.kind === 'transport-uncertainty') {
+                        progress.reachable = false;
+                        return;
+                    }
+                    if (result.kind !== 'action' && result.retryable) {
+                        progress.complete = false;
+                        return;
+                    }
+                }
+            }
+        },
         current() {
             return behind.size === 0;
         },
-        reconnected() {
-            for (const conversation of replicated)
-                gap(conversation);
+        known() {
+            return listKnown;
+        },
+        reopened() {
+            for (const [operation, dispatch] of sending)
+                if (!dispatch.answered)
+                    sending.delete(operation);
+        },
+        lost() {
+            catching.clear();
         },
         watch(conversation, options, deliver) {
-            const limit = limitOf(options);
-            const key = JSON.stringify([conversation, limit ?? null]);
+            const asked = askedOf(options);
+            const key = JSON.stringify([conversation, asked.limit, asked.after ?? null, asked.total]);
             const view = views.get(key) ?? {
                 conversation,
-                limit,
+                asked,
                 watchers: new Set(),
-                messages: null,
+                window: null,
+                more: false,
+                total: null,
             };
             views.set(key, view);
             const watcher = { notify: deliver, ready: false };
             view.watchers.add(watcher);
-            void deps
-                .durably(() => Promise.resolve())
+            const reading = new AbortController();
+            void untilAnswered(() => deps.durably(async (local) => {
+                if (view.window !== null)
+                    return;
+                const { messages, more } = await local.messageWindow(conversation, asked.limit, asked.before);
+                view.window = messages;
+                view.more = more;
+                view.total = asked.total ? await local.messageCount(conversation) : null;
+            }), reading.signal)
                 .then(() => {
                 if (deps.closed() || !view.watchers.has(watcher))
                     return;
                 watcher.ready = true;
-                watcher.notify(viewOf(conversation, limit));
+                const window = view.window ?? [];
+                watcher.notify(viewOf(conversation, window, sharedFrame(view, window)));
             })
                 .catch(() => { });
             return () => {
+                reading.abort();
                 if (!view.watchers.delete(watcher))
                     return;
                 if (view.watchers.size === 0)
@@ -670,35 +1068,26 @@ export function createConversationStore(deps) {
             };
         },
         watchList(deliver) {
-            listWatchers.add(deliver);
-            void agentsReady().then(() => {
-                if (!deps.closed() && listWatchers.has(deliver))
-                    deliver(entries());
-            });
+            unlisted.add(deliver);
+            learned();
             return () => {
+                unlisted.delete(deliver);
                 listWatchers.delete(deliver);
             };
         },
         watchAgents(deliver) {
-            agentWatchers.add(deliver);
-            void agentsReady().then(() => {
-                if (!deps.closed() && agentWatchers.has(deliver))
-                    deliver(agents());
-            });
+            unnamed.add(deliver);
+            learned();
+            readAgents();
             return () => {
+                unnamed.delete(deliver);
                 agentWatchers.delete(deliver);
             };
         },
+        learned,
         changed(set) {
             for (const conversation of set.conversations)
                 emit(conversation);
-            const declaration = deps.agents();
-            if (declaration !== undefined &&
-                set.documents.some((change) => change.locator === declaration.locator)) {
-                agentsRead = readAgents().catch(() => {
-                    agentsRead = null;
-                });
-            }
         },
         receive(event) {
             if (deps.closed())
@@ -706,37 +1095,53 @@ export function createConversationStore(deps) {
             if (event.kind === 'list' || event.kind === 'listed' || event.kind === 'unlisted') {
                 if (event.kind === 'list') {
                     listing.clear();
-                    for (const entry of event.entries)
+                    for (const entry of event.entries) {
                         listing.set(entry.conversation, { ...entry });
+                        creations.delete(entry.conversation);
+                    }
                     listKnown = true;
+                    for (const conversation of replicated) {
+                        if (!listing.has(conversation))
+                            continue;
+                        if (!missed(conversation))
+                            behind.delete(conversation);
+                        else if (!behind.has(conversation))
+                            gap(conversation);
+                    }
+                    openingEnded();
                 }
                 else if (event.kind === 'listed') {
                     listing.set(event.entry.conversation, { ...event.entry });
+                    creations.delete(event.entry.conversation);
                 }
                 else {
                     listing.delete(event.conversation);
                 }
+                keepList();
                 emitList();
-                return (event.kind !== 'list' &&
+                return ((event.kind !== 'list' &&
                     listKnown &&
                     (listing.size !== replicated.size ||
-                        [...listing.keys()].some((conversation) => !replicated.has(conversation))));
+                        [...listing.keys()].some((conversation) => !replicated.has(conversation)))) ||
+                    (listKnown && [...drafts.keys()].some(retiredChat)));
             }
             heard(event);
             return false;
         },
-        messages() {
-            return [...messages].flatMap(([conversation, held]) => held.map(({ identity, text }) => ({ conversation, identity, text })));
+        searchable() {
+            return [...(listKnown ? listing.keys() : stored)].sort();
         },
-        message(conversation, identity) {
-            const held = messages.get(conversation)?.find((message) => message.identity === identity);
-            return held === undefined ? null : { conversation, identity, text: held.text };
+        acquired(conversation) {
+            return reads.has(conversation) && !partials.has(conversation);
         },
         close() {
             views.clear();
             lives.clear();
+            unsent.clear();
             listWatchers.clear();
+            unlisted.clear();
             agentWatchers.clear();
+            unnamed.clear();
         },
     };
 }