@agentshouse/mdruntime 0.1.0-cac707d698ca2 → 0.1.0-cad267257ceaf

package/dist/conversation.js

@@ -1,9 +1,12 @@
 import { cursorOf, decodedCursor } from '@agentshouse/mdmodel';
 import { conversationChangeSet } from './change-set.js';
+import { heldFacts } from './conversation-row.js';
 import { runtimeError } from './failure.js';
 import { refusedForSpace } from './durability.js';
 import { changeBatchIdentity, chatDraftRevision } from './identity.js';
 import { OFFLINE } from './outcome.js';
+import { jobsOf, runningLine } from './parts.js';
+import { openQuestion, questionAsked } from './questions.js';
 import { untilAnswered } from './recovery.js';
 import { capped, FROM_START, messageOrder, precedes } from './windows.js';
 const QUIET = {
@@ -42,11 +45,14 @@ export function unheldView(conversation) {
         link: null,
         deliveryUnknown: [],
         chatDraft: null,
+        jobs: [],
     };
 }
 export const SESSION_STARTED = 'Session started';
 const NEW_CHAT = 'new:';
 export const HISTORY_CONVERSATIONS = 64;
+// A row is read at a glance and each telling clones the list to every observing tab, while a running line changes at each Kit flush.
+const ROW_INTERVAL_MS = 1_000;
 export function newChat(agent) {
     return `${NEW_CHAT}${agent}`;
 }
@@ -254,10 +260,6 @@ function returned(draft, submission, others) {
     }, others);
 }
 export function createConversationStore(deps) {
-    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();
@@ -265,15 +267,16 @@ export function createConversationStore(deps) {
     const lives = new Map();
     const unsent = new Map();
     const views = new Map();
-    const listing = new Map();
+    const heardNewest = new Map();
     let relisting = null;
-    let listCursor = null;
     const creations = new Set();
     const listWatchers = new Set();
     const unlisted = new Set();
     let listKnown = false;
-    let listHeld = false;
-    let listKept = false;
+    let listOwed = false;
+    let listTelling = false;
+    let rowTimer = null;
+    const closing = new AbortController();
     const agentWatchers = new Set();
     const unnamed = new Set();
     let agentsShown = null;
@@ -284,8 +287,7 @@ export function createConversationStore(deps) {
     function liveOf(conversation) {
         return lives.get(conversation) ?? QUIET;
     }
-    function viewOf(conversation, held, frame) {
-        const draft = drafts.get(conversation);
+    function viewOf(conversation, held, frame, draft, ended, marked) {
         const facts = liveOf(conversation);
         return {
             conversation,
@@ -299,16 +301,17 @@ export function createConversationStore(deps) {
             turn: structuredClone(facts.turn),
             questions: structuredClone(facts.questions),
             process: facts.process === null ? null : { ...facts.process },
-            processEnded: listing.get(conversation)?.processEnded ?? null,
+            processEnded: ended,
             commands: structuredClone(facts.commands),
             options: structuredClone(facts.options),
             starting: facts.starting,
             subagents: structuredClone(facts.subagents),
             link: facts.link === null ? null : { ...facts.link },
             deliveryUnknown: [...facts.deliveryUnknown],
-            chatDraft: draft === undefined || unwritten(draft)
-                ? null
-                : { text: draft.text, revision: draft.revision },
+            chatDraft: draft === null || unwritten(draft) ? null : { text: draft.text, revision: draft.revision },
+            jobs: facts.process?.running === false
+                ? []
+                : jobsOf(marked.filter(({ at }) => ended === null || at > ended), facts.turn),
         };
     }
     function emit(conversation) {
@@ -320,7 +323,7 @@ export function createConversationStore(deps) {
             const ready = [...view.watchers].filter((watcher) => watcher.ready);
             if (ready.length === 0)
                 continue;
-            const value = viewOf(conversation, view.window, sharedFrame(view, view.window));
+            const value = viewOf(conversation, view.window, sharedFrame(view, view.window), view.draft, view.ended, view.marked);
             for (const watcher of ready)
                 watcher.notify(value);
         }
@@ -330,11 +333,13 @@ export function createConversationStore(deps) {
     }
     async function slide(local, conversation, arriving) {
         let count;
+        let marked;
         for (const view of views.values()) {
             if (view.conversation !== conversation || view.window === null)
                 continue;
             if (arriving === null) {
                 view.window = [];
+                view.marked = [];
                 view.more = false;
                 if (view.total !== null)
                     view.total = 0;
@@ -344,6 +349,10 @@ export function createConversationStore(deps) {
             const next = windowOf(view.window, joining, view.asked.limit);
             view.window = next.messages;
             view.more ||= next.dropped;
+            if (arriving.length > 0) {
+                marked ??= await local.jobMarkers(conversation);
+                view.marked = marked;
+            }
             if (view.total !== null && arriving.length > 0) {
                 count ??= await local.messageCount(conversation);
                 view.total = count;
@@ -356,82 +365,179 @@ export function createConversationStore(deps) {
             return 'asking';
         return facts.turn === null ? 'idle' : 'working';
     }
-    function entries() {
-        return [...listing.values()].map((entry) => ({
+    function rowOf(conversation) {
+        const turn = lives.get(conversation)?.turn ?? null;
+        return {
+            state: stateOf(conversation),
+            started: turn?.started ?? null,
+            line: turn === null ? null : runningLine(turn.parts),
+            question: openQuestion(liveOf(conversation).questions),
+            asked: questionAsked(liveOf(conversation).questions),
+        };
+    }
+    async function entries() {
+        const list = await heldList();
+        if (list === null)
+            return null;
+        const held = list.length === 0
+            ? []
+            : await deps.durably((local) => local.conversationRows(list.map(({ conversation }) => conversation)));
+        const rows = new Map(held.map((one) => [one.conversation, one]));
+        return list.map((entry) => ({
             conversation: entry.conversation,
-            agent: { identity: entry.agent, name: entry.agentName },
+            agent: { identity: entry.agent, name: entry.agentName, retired: entry.agentRetired },
             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,
+            ...rowOf(entry.conversation),
+            ...heldFacts(rows.get(entry.conversation), entry),
         }));
     }
-    function keepList() {
-        if (!listKnown || listKept)
-            return;
-        listKept = true;
-        queueMicrotask(() => {
-            listKept = false;
-            if (deps.closed())
+    async function heldList() {
+        const stored = (await (await deps.local()).facts()).conversationList;
+        if (stored !== null)
+            return stored;
+        return !listKnown && deps.stream() !== undefined && deps.online() ? null : [];
+    }
+    async function endedIn(conversation) {
+        const list = await heldList();
+        return list?.find((entry) => entry.conversation === conversation)?.processEnded ?? null;
+    }
+    function listChanged(change) {
+        void deps
+            .durably(async (local) => {
+            const { conversationList, conversationCursor } = await local.facts();
+            const kept = change.replacing ? [] : (conversationList ?? []);
+            const held = new Map(kept.map((entry) => [entry.conversation, entry]));
+            for (const entry of change.set) {
+                held.set(entry.conversation, { ...entry });
+                creations.delete(entry.conversation);
+            }
+            if (change.gone !== null)
+                held.delete(change.gone);
+            const list = [...held.values()];
+            if (JSON.stringify(list) !== JSON.stringify(conversationList)) {
+                await local.fact('conversationList', list);
+            }
+            if (change.cursor !== undefined) {
+                if (change.cursor !== conversationCursor) {
+                    await local.fact('conversationCursor', change.cursor);
+                }
+                deps.stream()?.hold(change.cursor);
+            }
+            return list;
+        })
+            .catch(async () => (await (await deps.local()).facts()).conversationList ?? [])
+            .then((list) => {
+            if (deps.closed() || change.paged === true)
                 return;
-            const entries = [...listing.values()];
-            const cursor = listCursor;
-            void deps
-                .durably(async (local) => {
-                await local.fact('conversationList', entries);
-                await local.fact('conversationCursor', cursor);
-            })
-                .catch(() => { });
+            endedAnew(list);
+            if (change.cursor !== undefined) {
+                listKnown = true;
+                settleBehind(list);
+                openingEnded();
+                deps.settled();
+            }
+            emitList();
+            if (!listKnown)
+                return;
+            retiredDrafts(list);
+            if (change.cursor === undefined &&
+                (list.length !== replicated.size ||
+                    list.some(({ conversation }) => !replicated.has(conversation)))) {
+                deps.again();
+            }
+        }, () => { });
+    }
+    function endedAnew(list) {
+        const entries = new Map(list.map((entry) => [entry.conversation, entry]));
+        for (const view of views.values()) {
+            const ended = entries.get(view.conversation)?.processEnded ?? null;
+            if (view.window === null || ended === view.ended)
+                continue;
+            view.ended = ended;
+            emit(view.conversation);
+        }
+    }
+    let listShown = Promise.resolve();
+    function shownList(work) {
+        const reading = heldList();
+        listShown = listShown.then(async () => {
+            const list = await reading.catch(() => null);
+            if (list === null || deps.closed())
+                return;
+            work(list);
         });
     }
-    function listed(entry) {
-        const ended = listing.get(entry.conversation)?.processEnded ?? null;
-        listing.set(entry.conversation, { ...entry });
-        creations.delete(entry.conversation);
-        if (entry.processEnded !== ended)
-            emit(entry.conversation);
+    async function told() {
+        try {
+            while (listOwed && !deps.closed()) {
+                listOwed = false;
+                const value = await untilAnswered(entries, closing.signal);
+                if (deps.closed())
+                    return;
+                if (value === null)
+                    continue;
+                for (const watcher of listWatchers)
+                    watcher(value);
+                for (const watcher of [...unlisted]) {
+                    unlisted.delete(watcher);
+                    listWatchers.add(watcher);
+                    watcher(value);
+                }
+            }
+        }
+        finally {
+            listTelling = false;
+        }
+    }
+    function tellList() {
+        if (deps.closed() || (listWatchers.size === 0 && unlisted.size === 0))
+            return;
+        listOwed = true;
+        if (listTelling)
+            return;
+        listTelling = true;
+        void told().catch(() => { });
+    }
+    function tellSoon() {
+        if (rowTimer !== null)
+            return;
+        rowTimer = setTimeout(() => {
+            rowTimer = null;
+            tellList();
+        }, ROW_INTERVAL_MS);
     }
     function emitList() {
         if (deps.closed())
             return;
-        if (listWatchers.size > 0) {
-            const value = entries();
-            for (const watcher of listWatchers)
-                watcher(value);
-        }
+        tellList();
         emitAgents();
         learned();
     }
     function learned() {
         if (deps.closed())
             return;
-        if (!listKnown && !listHeld && deps.stream() !== undefined && deps.online())
+        if (unlisted.size > 0)
+            tellList();
+        if (unnamed.size === 0)
             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();
+        shownList((list) => {
+            const value = agents(list);
             for (const watcher of [...unnamed]) {
                 unnamed.delete(watcher);
                 agentWatchers.add(watcher);
                 watcher(value);
             }
-        }
+        });
     }
-    function agents() {
+    function agents(list) {
         const named = new Map();
         for (const agent of listedAgents ?? [])
             named.set(agent.agent, agent);
-        for (const entry of listing.values()) {
+        for (const entry of list) {
             named.set(entry.agent, { name: entry.agentName, retired: entry.agentRetired });
         }
         return [...named]
@@ -461,31 +567,35 @@ export function createConversationStore(deps) {
     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);
+        shownList((list) => {
+            const value = agents(list);
+            const shown = JSON.stringify(value);
+            if (shown === agentsShown)
+                return;
+            agentsShown = shown;
+            for (const watcher of agentWatchers)
+                watcher(value);
+        });
     }
     function setLive(conversation, next) {
-        const before = stateOf(conversation);
-        const began = lives.get(conversation)?.turn?.started;
+        const before = rowOf(conversation);
         if (next === null)
             lives.delete(conversation);
         else
             lives.set(conversation, next);
-        if (!listing.has(conversation))
-            return;
-        if (stateOf(conversation) !== before || next?.turn?.started !== began)
+        const after = rowOf(conversation);
+        if (after.state !== before.state || after.started !== before.started)
             emitList();
+        else if (after.line !== before.line ||
+            after.question !== before.question ||
+            after.asked !== before.asked)
+            tellSoon();
     }
-    function retiredChat(conversation) {
+    function retiredChat(conversation, list) {
         if (!conversation.startsWith(NEW_CHAT))
             return false;
         const agent = conversation.slice(NEW_CHAT.length);
-        return [...listing.values()].some((entry) => entry.agent === agent && entry.agentRetired);
+        return list.some((entry) => entry.agent === agent && entry.agentRetired);
     }
     function live(conversation, change) {
         const owed = unsent.get(conversation);
@@ -543,17 +653,23 @@ export function createConversationStore(deps) {
     }
     async function remove(leaving) {
         await deps.durably(async (local) => {
+            const kept = new Set([
+                ...(await local.conversations(leaving)).map(({ conversation }) => conversation),
+                ...(await local.chatDrafts())
+                    .filter(({ conversation }) => leaving.includes(conversation))
+                    .map(({ conversation }) => conversation),
+            ]);
             await local.dropConversations(leaving);
             const changed = [];
             for (const conversation of leaving) {
-                if (stored.has(conversation) || drafts.has(conversation) || lives.has(conversation)) {
+                if (kept.has(conversation) || lives.has(conversation))
                     changed.push(conversation);
+                for (const view of views.values()) {
+                    if (view.conversation === conversation)
+                        view.draft = null;
                 }
-                stored.delete(conversation);
-                reads.delete(conversation);
-                partials.delete(conversation);
-                drafts.delete(conversation);
                 behind.delete(conversation);
+                heardNewest.delete(conversation);
                 unsent.delete(conversation);
                 setLive(conversation, null);
                 await slide(local, conversation, null);
@@ -562,19 +678,68 @@ export function createConversationStore(deps) {
                 deps.publish(conversationChangeSet(changed));
         });
     }
-    function missed(conversation) {
-        const read = reads.get(conversation);
-        const newest = listing.get(conversation)?.newest;
+    function newestOfListed(entry) {
+        if (entry === undefined)
+            return undefined;
+        const heard = heardNewest.get(entry.conversation);
+        if (heard === undefined)
+            return entry.newest;
+        return entry.newest === null || heard > entry.newest ? heard : entry.newest;
+    }
+    function missed(conversation, held, entry) {
+        const read = held?.read;
+        const newest = newestOfListed(entry);
         return (read === undefined ||
             newest === undefined ||
-            partials.has(conversation) ||
+            held?.partial === true ||
             (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))
+    async function readsOf(local, conversations) {
+        return new Map((await local.conversations(conversations)).map((held) => [held.conversation, held]));
+    }
+    function retiredDrafts(list) {
+        if (!list.some((entry) => entry.agentRetired))
             return;
-        listing.set(conversation, { ...entry, newest: message.position });
+        void deps
+            .local()
+            .then((local) => local.chatDrafts())
+            .then((held) => {
+            if (!deps.closed() && held.some(({ conversation }) => retiredChat(conversation, list))) {
+                deps.again();
+            }
+        }, () => { });
+    }
+    function settleBehind(list) {
+        void deps
+            .durably(async (local) => {
+            const entries = new Map(list.map((entry) => [entry.conversation, entry]));
+            const named = [...replicated].filter((conversation) => entries.has(conversation));
+            const held = await readsOf(local, named);
+            let owed = false;
+            for (const conversation of named) {
+                if (!missed(conversation, held.get(conversation), entries.get(conversation))) {
+                    behind.delete(conversation);
+                }
+                else if (!behind.has(conversation)) {
+                    gap(conversation);
+                    owed = true;
+                }
+            }
+            return owed;
+        })
+            .then((owed) => {
+            if (deps.closed())
+                return;
+            deps.settled();
+            if (owed)
+                deps.again();
+        }, () => { });
+    }
+    function noted(conversation, message) {
+        const heard = heardNewest.get(conversation);
+        if (heard === undefined || message.position > heard) {
+            heardNewest.set(conversation, message.position);
+        }
     }
     function gap(conversation) {
         gaps.set(conversation, (gaps.get(conversation) ?? 0) + 1);
@@ -584,7 +749,7 @@ export function createConversationStore(deps) {
         return deps.durably(async (local) => {
             if (!replicated.has(conversation))
                 return;
-            const read = reads.get(conversation);
+            const read = (await readsOf(local, [conversation])).get(conversation)?.read;
             const advances = read !== undefined &&
                 !behind.has(conversation) &&
                 (read === null || message.position > read);
@@ -594,19 +759,18 @@ export function createConversationStore(deps) {
                 messages: [message],
                 ...(advances ? { read: { at: message.position, partial: false } } : {}),
             });
-            stored.add(conversation);
-            if (advances)
-                reads.set(conversation, message.position);
             sealTurns(conversation, new Set([message.turn]));
             await slide(local, conversation, [message]);
             deps.publish(conversationChangeSet([conversation]));
+            tellList();
         });
     }
     async function readHistories(conversations, ended) {
         const generations = new Map(conversations.map((one) => [one, gaps.get(one) ?? 0]));
+        const held = await readsOf(await deps.local(), conversations);
         let waiting = conversations.map((conversation) => ({
             conversation,
-            after: reads.get(conversation) ?? undefined,
+            after: held.get(conversation)?.read ?? undefined,
         }));
         while (waiting.length > 0) {
             const asking = waiting.slice(0, HISTORY_CONVERSATIONS);
@@ -662,15 +826,10 @@ export function createConversationStore(deps) {
                 return;
             const whole = next === undefined;
             const cursor = next ?? newestOf(arriving, from);
-            const partial = !whole && (partials.has(conversation) || !reads.has(conversation));
+            const held = (await readsOf(local, [conversation])).get(conversation);
+            const partial = !whole && (held?.partial === true || held?.read === undefined);
             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 (whole && (gaps.get(conversation) ?? 0) === generation)
                 behind.delete(conversation);
@@ -678,6 +837,8 @@ export function createConversationStore(deps) {
             if (arriving.length > 0 || sealing || whole) {
                 deps.publish(conversationChangeSet([conversation]));
             }
+            if (arriving.length > 0)
+                tellSoon();
         });
     }
     function heard(event) {
@@ -744,17 +905,24 @@ export function createConversationStore(deps) {
             emit(conversation);
     }
     async function kept(local, conversation, following) {
-        if (following === null || empty(following)) {
+        const shown = following === null || empty(following) ? null : following;
+        if (shown === null)
             await local.dropChatDraft(conversation);
-            drafts.delete(conversation);
-        }
-        else {
-            await local.keepChatDrafts([following]);
-            drafts.set(conversation, following);
+        else
+            await local.keepChatDrafts([shown]);
+        shownDraft(conversation, shown);
+    }
+    function shownDraft(conversation, draft) {
+        for (const view of views.values()) {
+            if (view.conversation === conversation)
+                view.draft = draft;
         }
     }
+    async function draftAt(local, conversation) {
+        return (await local.chatDraft(conversation)) ?? undefined;
+    }
     async function sealed(local, conversation, turns) {
-        const held = drafts.get(conversation);
+        const held = await draftAt(local, conversation);
         const submitted = held?.submitted ?? [];
         const left = submitted.filter((one) => one.turn === null || !turns.has(one.turn));
         if (held === undefined || left.length === submitted.length)
@@ -765,7 +933,7 @@ export function createConversationStore(deps) {
     function moved(agent, operation, to) {
         const from = newChat(agent);
         return deps.durably(async (local) => {
-            const held = drafts.get(from);
+            const held = await draftAt(local, from);
             const earlier = held?.moves ?? [];
             if (earlier.includes(operation))
                 return;
@@ -775,18 +943,20 @@ export function createConversationStore(deps) {
                 revision: chatDraftRevision(),
             };
             const { moves: _answered, ...unsent } = held ?? blank;
-            const taken = drafts.has(to) || empty(unsent) ? [] : [{ ...unsent, conversation: to }];
+            const taken = (await draftAt(local, to)) !== undefined || empty(unsent)
+                ? []
+                : [{ ...unsent, conversation: to }];
             const left = { ...(taken.length === 0 ? unsent : blank), moves: [...earlier, operation] };
             await local.keepChatDrafts([left, ...taken]);
-            drafts.set(from, left);
+            shownDraft(from, left);
             for (const one of taken)
-                drafts.set(to, one);
+                shownDraft(to, one);
             deps.publish(conversationChangeSet([from, to]));
         });
     }
     function withDraft(conversation, next) {
         return deps.durably(async (local) => {
-            const following = await next(drafts.get(conversation), local);
+            const following = await next(await draftAt(local, conversation), local);
             if (following === undefined)
                 return;
             await kept(local, conversation, following);
@@ -868,7 +1038,8 @@ export function createConversationStore(deps) {
             return deps.durably(async (local) => {
                 const { messages, more } = await local.messageWindow(conversation, asked.limit, asked.before, phrase);
                 const total = asked.total ? await local.messageCount(conversation, phrase) : null;
-                return structuredClone(viewOf(conversation, messages, frameOf(asked, messages, more, total)));
+                const marked = await local.jobMarkers(conversation);
+                return structuredClone(viewOf(conversation, messages, frameOf(asked, messages, more, total), (await local.chatDraft(conversation)) ?? null, await endedIn(conversation), marked));
             });
         },
         async create(input) {
@@ -876,8 +1047,10 @@ export function createConversationStore(deps) {
             const conversation = answered(result, 'conversation_id');
             if (conversation === null)
                 return result;
-            if (!listing.has(conversation))
+            const listed = (await heldList()) ?? [];
+            if (!listed.some((entry) => entry.conversation === conversation)) {
                 creations.add(conversation);
+            }
             const creation = creationOf(input);
             if (creation !== null)
                 await moved(creation.agent, creation.operation, conversation);
@@ -945,43 +1118,40 @@ export function createConversationStore(deps) {
     return {
         surface,
         chatDraft,
-        hydrate(held, kept, list, cursor) {
-            if (list !== null && !listKnown) {
-                listing.clear();
-                for (const entry of list)
-                    listing.set(entry.conversation, { ...entry });
-                listHeld = true;
-                listCursor = cursor;
-                deps.stream()?.hold(cursor);
-            }
-            stored.clear();
-            reads.clear();
-            partials.clear();
-            for (const entry of held) {
-                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 kept)
-                drafts.set(record.conversation, record);
-            if (listHeld)
-                learned();
+        async opened(local) {
+            const { conversationList, conversationCursor } = await local.facts();
+            if (conversationList === null || listKnown)
+                return;
+            deps.stream()?.hold(conversationCursor);
+            learned();
         },
         async reconcile() {
             if (!listKnown)
                 return;
-            const named = new Set(listing.keys());
+            const local = await deps.local();
+            const [held, kept, { conversationList }] = await Promise.all([
+                local.conversations(),
+                local.chatDrafts(),
+                local.facts(),
+            ]);
+            const list = conversationList ?? [];
+            const entries = new Map(list.map((entry) => [entry.conversation, entry]));
+            const named = new Set(entries.keys());
+            const reads = new Map(held.map((one) => [one.conversation, one]));
             const leaving = [
-                ...new Set([...replicated, ...stored, ...reads.keys(), ...drafts.keys()]),
+                ...new Set([
+                    ...replicated,
+                    ...reads.keys(),
+                    ...kept.map(({ conversation }) => conversation),
+                ]),
             ].filter((conversation) => !named.has(conversation) &&
                 !creations.has(conversation) &&
-                (!conversation.startsWith(NEW_CHAT) || retiredChat(conversation)));
+                (!conversation.startsWith(NEW_CHAT) || retiredChat(conversation, list)));
             for (const conversation of named) {
-                if (!replicated.has(conversation) && missed(conversation))
+                if (!replicated.has(conversation) &&
+                    missed(conversation, reads.get(conversation), entries.get(conversation))) {
                     behind.add(conversation);
+                }
             }
             replicated = named;
             handReplicated();
@@ -1012,12 +1182,16 @@ export function createConversationStore(deps) {
                 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;
+            const local = await deps.local();
+            const tried = new Set();
+            for (const { conversation } of await local.chatDrafts()) {
+                for (;;) {
+                    const submission = (await local.chatDraft(conversation))?.submitted?.find((one) => one.turn === null && !sending.has(one.operation) && !tried.has(one.operation));
+                    if (submission === undefined)
+                        break;
                     if (deps.closed())
                         return;
+                    tried.add(submission.operation);
                     const result = await dispatched(conversation, submission);
                     if (result.kind === 'revoked-authorization')
                         return;
@@ -1055,6 +1229,9 @@ export function createConversationStore(deps) {
                 asked,
                 watchers: new Set(),
                 window: null,
+                draft: null,
+                ended: null,
+                marked: [],
                 more: false,
                 total: null,
             };
@@ -1066,7 +1243,10 @@ export function createConversationStore(deps) {
                 if (view.window !== null)
                     return;
                 const { messages, more } = await local.messageWindow(conversation, asked.limit, asked.before);
+                view.draft = (await local.chatDraft(conversation)) ?? null;
+                view.ended = await endedIn(conversation);
                 view.window = messages;
+                view.marked = await local.jobMarkers(conversation);
                 view.more = more;
                 view.total = asked.total ? await local.messageCount(conversation) : null;
             }), reading.signal)
@@ -1075,7 +1255,7 @@ export function createConversationStore(deps) {
                     return;
                 watcher.ready = true;
                 const window = view.window ?? [];
-                watcher.notify(viewOf(conversation, window, sharedFrame(view, window)));
+                watcher.notify(viewOf(conversation, window, sharedFrame(view, window), view.draft, view.ended, view.marked));
             })
                 .catch(() => { });
             return () => {
@@ -1110,58 +1290,43 @@ export function createConversationStore(deps) {
         },
         receive(event) {
             if (deps.closed())
-                return false;
-            if (event.kind === 'list' || event.kind === 'listed' || event.kind === 'unlisted') {
-                if (event.kind === 'list') {
-                    if (event.whole)
-                        relisting ??= new Map();
-                    for (const entry of event.entries) {
-                        if (relisting === null)
-                            listed(entry);
-                        else
-                            relisting.set(entry.conversation, { ...entry });
-                    }
-                    if (event.more)
-                        return false;
-                    if (relisting !== null) {
-                        listing.clear();
-                        for (const entry of relisting.values())
-                            listed(entry);
-                        relisting = null;
-                    }
-                    listCursor = event.cursor;
-                    deps.stream()?.hold(event.cursor);
-                    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') {
-                    listed(event.entry);
-                    relisting?.set(event.entry.conversation, { ...event.entry });
-                }
-                else {
-                    listing.delete(event.conversation);
-                    relisting?.delete(event.conversation);
+                return;
+            if (event.kind === 'list') {
+                if (event.whole)
+                    relisting ??= new Map();
+                if (relisting !== null) {
+                    for (const entry of event.entries)
+                        relisting.set(entry.conversation, { ...entry });
                 }
-                keepList();
-                emitList();
-                return ((event.kind !== 'list' &&
-                    listKnown &&
-                    (listing.size !== replicated.size ||
-                        [...listing.keys()].some((conversation) => !replicated.has(conversation)))) ||
-                    (listKnown && [...drafts.keys()].some(retiredChat)));
+                if (event.more && relisting !== null)
+                    return;
+                const whole = relisting;
+                relisting = null;
+                listChanged({
+                    replacing: whole !== null,
+                    set: whole === null ? event.entries : [...whole.values()],
+                    gone: null,
+                    ...(event.more ? { paged: true } : { cursor: event.cursor }),
+                });
+                return;
+            }
+            if (event.kind === 'listed') {
+                relisting?.set(event.entry.conversation, { ...event.entry });
+                listChanged({ replacing: false, set: [event.entry], gone: null });
+                return;
+            }
+            if (event.kind === 'unlisted') {
+                relisting?.delete(event.conversation);
+                listChanged({ replacing: false, set: [], gone: event.conversation });
+                return;
             }
             heard(event);
-            return false;
         },
         close() {
+            closing.abort();
+            if (rowTimer !== null)
+                clearTimeout(rowTimer);
+            rowTimer = null;
             views.clear();
             lives.clear();
             unsent.clear();