@agentshouse/mdruntime 0.1.0-c3903a68dcbbf → 0.1.0-c435c7a7c4f4e

package/dist/conversation.js

@@ -1,14 +1,87 @@
 import { conversationChangeSet } from './change-set.js';
+import { runtimeError } from './failure.js';
 import { declaredFile } from './file.js';
+import { changeBatchIdentity, chatDraftRevision } from './identity.js';
+import { OFFLINE } from './outcome.js';
 const QUIET = {
-    growingText: null,
-    plan: null,
-    workingNote: null,
+    turn: null,
     questions: [],
     process: null,
     commands: [],
     options: [],
 };
+export function unheldView(conversation) {
+    return {
+        conversation,
+        messages: [],
+        turn: null,
+        questions: [],
+        process: null,
+        commands: [],
+        options: [],
+        chatDraft: null,
+    };
+}
+export const SESSION_STARTED = 'Session started';
+const NEW_CHAT = 'new:';
+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 } = input;
+    return typeof agent === 'string' && typeof operation === 'string' ? { agent, operation } : null;
+}
+function startedTurn(turn, operation) {
+    if (operation.op === 'begin')
+        return { turn, started: operation.at, parts: [], context: null };
+    if (operation.op === 'context') {
+        return {
+            turn,
+            started: null,
+            parts: [],
+            context: { used: operation.used, window: operation.window },
+        };
+    }
+    return operation.op === 'start' && operation.index === 0
+        ? { turn, started: null, parts: [structuredClone(operation.part)], context: null }
+        : null;
+}
+function changedFields(part, operation) {
+    if (operation.op === 'append') {
+        return { text: `${String(part.text ?? '')}${operation.text}` };
+    }
+    if (operation.op === 'status') {
+        return { status: operation.status, result: structuredClone(operation.result) };
+    }
+    if (operation.op === 'count')
+        return { count: operation.count };
+    return { entries: structuredClone(operation.entries) };
+}
+function appliedTurn(held, operation) {
+    if (operation.op === 'begin')
+        return { ...held, started: operation.at };
+    if (operation.op === 'context') {
+        return { ...held, context: { used: operation.used, window: operation.window } };
+    }
+    if (operation.op === 'start') {
+        if (operation.index !== 0 && operation.index !== held.parts.length)
+            return null;
+        return {
+            ...held,
+            parts: [...held.parts.slice(0, operation.index), structuredClone(operation.part)],
+        };
+    }
+    const part = held.parts[operation.index];
+    if (typeof part !== 'object' || part === null)
+        return null;
+    const changed = { ...part, ...changedFields(part, operation) };
+    return {
+        ...held,
+        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;
@@ -16,11 +89,15 @@ function ordered(left, right) {
         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(ordered);
+    return limit === undefined ? next : next.slice(Math.max(0, next.length - limit));
+}
+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)
@@ -79,90 +156,227 @@ 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) {
-        throw new Error(`conversation limit must be a non-negative integer, got ${String(limit)}`);
+        throw runtimeError('invalid-limit', `conversation limit must be a non-negative integer, got ${String(limit)}`);
     }
     return limit;
 }
+const EXPIRED = { kind: 'rejected', code: 'expired', fields: {}, retryable: false };
+function unwritten(draft) {
+    return draft.text === '' && draft.files.length === 0;
+}
+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 returned(draft, submission, others) {
+    return withSubmitted({
+        conversation: draft.conversation,
+        text: [submission.text, draft.text].filter((one) => one !== '').join('\n'),
+        files: [...submission.files, ...draft.files],
+        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 gaps = new Map();
     const lives = new Map();
     const views = new Map();
+    const listing = new Map();
+    const creations = new Set();
+    const listWatchers = new Set();
+    let listKnown = false;
+    const agentWatchers = new Set();
+    let agentNames = new Map();
+    let retiredAgents = new Set();
+    let agentsRead = null;
     let replicated = new Set();
     let handedReplicated;
     function liveOf(conversation) {
         return lives.get(conversation) ?? QUIET;
     }
-    function viewOf(conversation, limit) {
-        const held = messages.get(conversation) ?? [];
-        const shown = limit === undefined ? held : held.slice(Math.max(0, held.length - limit));
+    function viewOf(conversation, held) {
         const draft = drafts.get(conversation);
         const facts = liveOf(conversation);
         return {
             conversation,
-            messages: shown.map(({ identity, turn, text, message }) => ({
+            messages: held.map(({ identity, turn, text, message }) => ({
                 identity,
                 turn,
                 text,
-                message: structuredClone(message),
+                message,
             })),
-            growingText: facts.growingText === null ? null : { ...facts.growingText },
-            workingNote: facts.workingNote === null ? null : { ...facts.workingNote },
-            plan: structuredClone(facts.plan?.plan ?? null),
+            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
+            chatDraft: draft === undefined || unwritten(draft)
                 ? null
-                : { text: draft.text, files: [...draft.files] },
+                : { text: draft.text, files: [...draft.files], revision: draft.revision },
         };
     }
     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;
             const ready = [...view.watchers].filter((watcher) => watcher.ready);
             if (ready.length === 0)
                 continue;
-            const value = viewOf(conversation, view.limit);
+            const value = viewOf(conversation, view.window);
             for (const watcher of ready)
                 watcher.notify(value);
         }
     }
+    function slide(conversation, arriving) {
+        for (const view of views.values()) {
+            if (view.conversation !== conversation || view.window === null)
+                continue;
+            view.window = arriving === null ? [] : windowOf(view.window, arriving, view.limit);
+        }
+    }
+    function changesOf(conversation, arriving) {
+        return arriving.map(({ identity, text }) => ({ conversation, identity, text }));
+    }
+    function stateOf(conversation) {
+        const facts = liveOf(conversation);
+        if (facts.questions.length > 0)
+            return 'asking';
+        return facts.turn === null ? 'idle' : 'working';
+    }
+    function entries() {
+        return [...listing.values()].map((entry) => ({
+            conversation: entry.conversation,
+            agent: { identity: entry.agent, name: agentNames.get(entry.agent) ?? null },
+            name: entry.name,
+            created: entry.created,
+            finished: entry.finished,
+            outcome: entry.outcome,
+            state: stateOf(entry.conversation),
+            started: lives.get(entry.conversation)?.turn?.started ?? null,
+        }));
+    }
+    function emitList() {
+        if (deps.closed() || listWatchers.size === 0)
+            return;
+        const value = entries();
+        for (const watcher of listWatchers)
+            watcher(value);
+    }
+    function agents() {
+        return [...agentNames]
+            .filter(([identity]) => !retiredAgents.has(identity))
+            .map(([identity, name]) => ({ identity, name }))
+            .sort((left, right) => left.name === right.name
+            ? left.identity.localeCompare(right.identity)
+            : left.name.localeCompare(right.name));
+    }
+    function emitAgents() {
+        if (deps.closed() || agentWatchers.size === 0)
+            return;
+        const value = agents();
+        for (const watcher of agentWatchers)
+            watcher(value);
+    }
+    function setLive(conversation, next) {
+        const before = stateOf(conversation);
+        const began = lives.get(conversation)?.turn?.started;
+        if (next === null)
+            lives.delete(conversation);
+        else
+            lives.set(conversation, next);
+        if (!listing.has(conversation))
+            return;
+        if (stateOf(conversation) !== before || next?.turn?.started !== began)
+            emitList();
+    }
+    async function readAgents() {
+        const declaration = deps.agents();
+        if (declaration === undefined)
+            return;
+        const held = await deps.documents(declaration);
+        if ('pending' in held)
+            return;
+        const { documents } = held;
+        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();
+        const ended = [...drafts.keys()].filter(retiredChat);
+        if (ended.length > 0)
+            await remove(ended);
+    }
+    function retiredChat(conversation) {
+        return (conversation.startsWith(NEW_CHAT) && retiredAgents.has(conversation.slice(NEW_CHAT.length)));
+    }
+    function agentsReady() {
+        agentsRead ??= readAgents().catch(() => {
+            agentsRead = null;
+        });
+        return agentsRead;
+    }
     function live(conversation, change) {
-        lives.set(conversation, { ...liveOf(conversation), ...change });
+        setLive(conversation, { ...liveOf(conversation), ...change });
         emit(conversation);
     }
+    function relayed(conversation, turn, operation) {
+        const held = liveOf(conversation).turn;
+        const next = held?.turn === turn ? appliedTurn(held, operation) : startedTurn(turn, operation);
+        if (next !== null)
+            live(conversation, { turn: next });
+    }
     function sealTurns(conversation, turns) {
         const held = lives.get(conversation);
-        if (held === undefined)
-            return false;
-        const growingText = held.growingText !== null && turns.has(held.growingText.turn) ? null : held.growingText;
-        const plan = held.plan !== null && turns.has(held.plan.turn) ? null : held.plan;
-        if (growingText === held.growingText && plan === held.plan)
+        if (held?.turn == null || !turns.has(held.turn.turn))
             return false;
-        lives.set(conversation, { ...held, growingText, plan });
+        setLive(conversation, { ...held, turn: null });
         return true;
     }
     function handReplicated() {
@@ -176,44 +390,27 @@ export function createConversationStore(deps) {
         handedReplicated = named;
         stream.replicate(held);
     }
-    async function documented() {
-        const declaration = deps.cards();
-        if (declaration === undefined)
-            return [];
-        const { documents } = await deps.documents(declaration.locator);
-        return documents.filter((document) => typeof document.type === 'string');
-    }
-    function carded(documents) {
-        const declaration = deps.cards();
-        if (declaration === undefined)
-            return [];
-        const cards = [];
-        for (const card of documents) {
-            if (card.type !== declaration.type)
-                continue;
-            const identity = card.fields[declaration.identity];
-            if (typeof identity === 'string')
-                cards.push({ conversation: identity, card });
-        }
-        return cards;
-    }
     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 });
+                for (const identity of await local.messageIdentities(conversation)) {
+                    removed.push({ conversation, identity, text: null });
                 }
-                if (messages.has(conversation) || drafts.has(conversation) || lives.has(conversation)) {
+            }
+            await local.dropConversations(leaving);
+            const changed = [];
+            for (const conversation of leaving) {
+                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);
-                lives.delete(conversation);
+                setLive(conversation, null);
+                slide(conversation, null);
             }
             if (changed.length > 0)
                 deps.publish(conversationChangeSet(removed, changed));
@@ -231,30 +428,25 @@ 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]));
+            slide(conversation, [message]);
+            deps.publish(conversationChangeSet(changesOf(conversation, [message]), [conversation]));
         });
     }
     async function readHistories(conversations) {
         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) => ({
             conversation,
-            after: starts.get(conversation) ?? undefined,
+            after: reads.get(conversation) ?? undefined,
         }));
         while (asking.length > 0) {
             const result = await deps.call('conversation.history', {
@@ -266,124 +458,244 @@ 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);
-        }
         return null;
     }
-    function keepHistory(conversation, arriving, from, generation) {
+    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]));
+            slide(conversation, arriving);
+            if (arriving.length > 0 || sealing || whole) {
+                deps.publish(conversationChangeSet(changesOf(conversation, arriving), [conversation]));
             }
         });
     }
+    function heard(event) {
+        const { conversation } = event;
+        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);
+            return;
+        }
+        if (event.kind === 'turn') {
+            relayed(conversation, event.turn, event.operation);
+            return;
+        }
+        if (event.kind === 'questions') {
+            live(conversation, { questions: structuredClone(event.questions) });
+            return;
+        }
+        if (event.kind === 'process') {
+            live(conversation, { process: { running: event.running } });
+            return;
+        }
+        if (event.kind === 'commands') {
+            live(conversation, { commands: structuredClone(event.commands) });
+            return;
+        }
+        if (event.kind === 'options') {
+            live(conversation, { options: structuredClone(event.options) });
+            return;
+        }
+        const arriving = acceptedMessage(event.message);
+        if (arriving === null)
+            return;
+        if (replicated.has(conversation)) {
+            void keep(conversation, arriving).catch(() => { });
+            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: '',
+                files: [],
+                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);
-            }
+            await kept(local, conversation, following);
             deps.publish(conversationChangeSet([], [conversation]));
         });
     }
+    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 ?? '',
+                files: [...(said?.files ?? [])],
+                turn: null,
+            };
+            return {
+                conversation,
+                ...(draft === undefined || current === undefined
+                    ? { text: '', files: [], revision: chatDraftRevision() }
+                    : { text: current.text, files: current.files, 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 = {};
+        sending.set(submission.operation, dispatch);
+        try {
+            const files = await Promise.all(submission.files.map(async (file) => ({ ...(await declaredFile(file)), blob: file.blob })));
+            const result = await invoke('conversation.send', conversation, {
+                text: submission.text,
+                files,
+                operation_id: submission.operation,
+            });
+            if (result.kind === 'revoked-authorization')
+                return result;
+            if (result.kind !== 'action' && result.retryable) {
+                deps.unanswered();
+                return result;
+            }
+            const turn = answered(result, 'turn');
+            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 = {}) {
         return deps.call(name, { conversation, ...extra });
     }
     const surface = {
         async list() {
-            const declaration = deps.cards();
-            if (declaration === undefined)
-                return [];
-            const documents = await documented();
-            const entries = carded(documents).map(({ conversation, card }) => ({
-                conversation,
-                card,
-                agent: documents.find((document) => document.backlinks.some((backlink) => backlink.path === card.path && backlink.field === declaration.agent)) ?? null,
-            }));
-            entries.sort((left, right) => (left.conversation < right.conversation ? -1 : 1));
-            return entries;
+            await agentsReady();
+            return entries();
         },
         async read(conversation, options = {}) {
             const limit = limitOf(options);
-            return deps.durably(() => Promise.resolve(viewOf(conversation, limit)));
+            return deps.durably(async (local) => structuredClone(viewOf(conversation, await local.messageWindow(conversation, limit))));
         },
-        create(input) {
-            return deps.call('conversation.create', input);
-        },
-        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 create(input) {
+            const result = await deps.call('conversation.create', input);
+            const conversation = answered(result, 'conversation');
+            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, operation = changeBatchIdentity(), draft) {
+            if (deps.online()) {
+                const { submission, earlier } = await submitted(conversation, operation, draft);
+                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: '', files: [], revision: '' }, { operation, ...draft, turn: null }, current?.submitted ?? []));
             }
+            return OFFLINE;
         },
         answer(conversation, answer) {
             return invoke('conversation.answer', conversation, { answer });
@@ -398,7 +710,12 @@ export function createConversationStore(deps) {
             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 });
+            await withDraft(conversation, (current) => {
+                const held = current?.submitted?.find((one) => one.turn === turn);
+                if (current === undefined || held === undefined)
+                    return undefined;
+                return returned(current, held, current.submitted.filter((one) => one !== held));
+            });
             return result;
         },
         delete(conversation) {
@@ -406,38 +723,54 @@ export function createConversationStore(deps) {
         },
     };
     const chatDraft = {
-        write(conversation, draft) {
-            return withDraft(conversation, () => ({
+        write(conversation, draft, revision = chatDraftRevision()) {
+            return withDraft(conversation, (current) => ({
                 conversation,
                 text: draft.text,
                 files: [...draft.files],
-                turn: null,
+                revision,
+                ...(current === undefined ? {} : pending(current)),
             }));
         },
         discard(conversation) {
-            return withDraft(conversation, (current) => (current === undefined ? undefined : null));
+            return withDraft(conversation, (current) => current === undefined
+                ? undefined
+                : {
+                    conversation,
+                    text: '',
+                    files: [],
+                    revision: chatDraftRevision(),
+                    ...pending(current),
+                });
         },
     };
     return {
         surface,
         chatDraft,
-        hydrate(held, stored) {
-            messages.clear();
+        hydrate(held, kept) {
+            stored.clear();
             reads.clear();
+            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);
         },
         async reconcile() {
-            const named = new Set(carded(await documented()).map((entry) => entry.conversation));
+            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))
                     behind.add(conversation);
@@ -457,27 +790,65 @@ export function createConversationStore(deps) {
             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;
         },
+        known() {
+            return listKnown;
+        },
         reconnected() {
             for (const conversation of replicated)
                 gap(conversation);
         },
+        reopened() {
+            sending.clear();
+        },
         watch(conversation, options, deliver) {
             const limit = limitOf(options);
             const key = JSON.stringify([conversation, limit ?? null]);
-            const view = views.get(key) ?? { conversation, limit, watchers: new Set() };
+            const view = views.get(key) ?? {
+                conversation,
+                limit,
+                watchers: new Set(),
+                window: null,
+            };
             views.set(key, view);
             const watcher = { notify: deliver, ready: false };
             view.watchers.add(watcher);
             void deps
-                .durably(() => Promise.resolve())
+                .durably(async (local) => {
+                view.window ??= await local.messageWindow(conversation, limit);
+            })
                 .then(() => {
                 if (deps.closed() || !view.watchers.has(watcher))
                     return;
                 watcher.ready = true;
-                watcher.notify(viewOf(conversation, limit));
+                watcher.notify(viewOf(conversation, view.window ?? []));
             })
                 .catch(() => { });
             return () => {
@@ -487,71 +858,76 @@ export function createConversationStore(deps) {
                     views.delete(key);
             };
         },
+        watchList(deliver) {
+            listWatchers.add(deliver);
+            void agentsReady().then(() => {
+                if (!deps.closed() && listWatchers.has(deliver))
+                    deliver(entries());
+            });
+            return () => {
+                listWatchers.delete(deliver);
+            };
+        },
+        watchAgents(deliver) {
+            agentWatchers.add(deliver);
+            void agentsReady().then(() => {
+                if (!deps.closed() && agentWatchers.has(deliver))
+                    deliver(agents());
+            });
+            return () => {
+                agentWatchers.delete(deliver);
+            };
+        },
         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())
-                return;
-            const { conversation } = event;
-            if (event.kind === 'gap') {
-                if (replicated.has(conversation))
-                    gap(conversation);
-                if (lives.delete(conversation))
-                    emit(conversation);
-                return;
-            }
-            if (event.kind === 'growing-text') {
-                live(conversation, { growingText: { turn: event.turn, text: event.text } });
-                return;
-            }
-            if (event.kind === 'plan') {
-                live(conversation, { plan: { turn: event.turn, plan: structuredClone(event.plan) } });
-                return;
-            }
-            if (event.kind === 'working-note') {
-                live(conversation, {
-                    workingNote: event.note === null ? null : { noteId: event.note.noteId, text: event.note.text },
-                });
-                return;
-            }
-            if (event.kind === 'questions') {
-                live(conversation, { questions: structuredClone(event.questions) });
-                return;
-            }
-            if (event.kind === 'process') {
-                live(conversation, { process: { running: event.running } });
-                return;
-            }
-            if (event.kind === 'commands') {
-                live(conversation, { commands: structuredClone(event.commands) });
-                return;
-            }
-            if (event.kind === 'options') {
-                live(conversation, { options: structuredClone(event.options) });
-                return;
-            }
-            const arriving = acceptedMessage(event.message);
-            if (arriving === null)
-                return;
-            if (replicated.has(conversation)) {
-                void keep(conversation, arriving).catch(() => { });
-                return;
+                return false;
+            if (event.kind === 'list' || event.kind === 'listed' || event.kind === 'unlisted') {
+                if (event.kind === 'list') {
+                    listing.clear();
+                    for (const entry of event.entries) {
+                        listing.set(entry.conversation, { ...entry });
+                        creations.delete(entry.conversation);
+                    }
+                    listKnown = true;
+                }
+                else if (event.kind === 'listed') {
+                    listing.set(event.entry.conversation, { ...event.entry });
+                    creations.delete(event.entry.conversation);
+                }
+                else {
+                    listing.delete(event.conversation);
+                }
+                emitList();
+                return (event.kind !== 'list' &&
+                    listKnown &&
+                    (listing.size !== replicated.size ||
+                        [...listing.keys()].some((conversation) => !replicated.has(conversation))));
             }
-            if (sealTurns(conversation, new Set([arriving.turn])))
-                emit(conversation);
+            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();
+            listWatchers.clear();
+            agentWatchers.clear();
         },
     };
 }